CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/activities/bulkDelete");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/activities/bulkDelete" {:content-type :json
                                                                    :form-params {:id []}})

require "http/client"

url = "{{baseUrl}}/activities/bulkDelete"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": []\n}"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/activities/bulkDelete"

	payload := strings.NewReader("{\n  \"id\": []\n}")

	req, _ := http.NewRequest("DELETE", 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))

}

DELETE /baseUrl/activities/bulkDelete HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 14

{
  "id": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/activities/bulkDelete")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/activities/bulkDelete")
  .header("content-type", "application/json")
  .body("{\n  \"id\": []\n}")
  .asString();

const data = JSON.stringify({
  id: []
});

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

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

xhr.open('DELETE', '{{baseUrl}}/activities/bulkDelete');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/activities/bulkDelete',
  headers: {'content-type': 'application/json'},
  data: {id: []}
};

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

const url = '{{baseUrl}}/activities/bulkDelete';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '{"id":[]}'
};

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}}/activities/bulkDelete',
  method: 'DELETE',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/activities/bulkDelete")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/activities/bulkDelete',
  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({id: []}));
req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/activities/bulkDelete',
  headers: {'content-type': 'application/json'},
  body: {id: []},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/activities/bulkDelete');

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

req.type('json');
req.send({
  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}}/activities/bulkDelete',
  headers: {'content-type': 'application/json'},
  data: {id: []}
};

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

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

const url = '{{baseUrl}}/activities/bulkDelete';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '{"id":[]}'
};

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

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

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

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

 "{{baseUrl}}/activities/bulkDelete",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => [
        
    ]
  ]),
  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('DELETE', '{{baseUrl}}/activities/bulkDelete', [
  'body' => '{
  "id": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/activities/bulkDelete');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

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

append(json_encode([
  'id' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/activities/bulkDelete');
$request->setRequestMethod('DELETE');
$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}}/activities/bulkDelete' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "id": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/activities/bulkDelete' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "id": []
}'

import http.client

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

payload = "{\n  \"id\": []\n}"

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

conn.request("DELETE", "/baseUrl/activities/bulkDelete", payload, headers)

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

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

import requests

url = "{{baseUrl}}/activities/bulkDelete"

payload = { "id": [] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/activities/bulkDelete"

payload <- "{\n  \"id\": []\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/activities/bulkDelete")

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

request = Net::HTTP::Delete.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": []\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.delete('/baseUrl/activities/bulkDelete') do |req|
  req.body = "{\n  \"id\": []\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}}/activities/bulkDelete";

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

    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("DELETE").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "id": []
}' |  \
  http DELETE {{baseUrl}}/activities/bulkDelete \
  content-type:application/json

wget --quiet \
  --method DELETE \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": []\n}' \
  --output-document \
  - {{baseUrl}}/activities/bulkDelete

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/activities/bulkDelete")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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}}/activities");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/activities" {:content-type :json
                                                       :form-params {:hex_code ""
                                                                     :name ""}})

require "http/client"

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

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"hex_code\": \"\",\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/activities HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "hex_code": "",
  "name": ""
}

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

client.close();

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

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

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

const data = JSON.stringify({
  hex_code: '',
  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}}/activities');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/activities',
  headers: {'content-type': 'application/json'},
  data: {hex_code: '', name: ''}
};

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

const url = '{{baseUrl}}/activities';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"hex_code":"","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}}/activities',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "hex_code": "",\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  \"hex_code\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/activities")
  .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/activities',
  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({hex_code: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/activities',
  headers: {'content-type': 'application/json'},
  body: {hex_code: '', 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}}/activities');

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

req.type('json');
req.send({
  hex_code: '',
  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}}/activities',
  headers: {'content-type': 'application/json'},
  data: {hex_code: '', name: ''}
};

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

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

const url = '{{baseUrl}}/activities';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"hex_code":"","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 = @{ @"hex_code": @"",
                              @"name": @"" };

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

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

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

 "{{baseUrl}}/activities",
  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([
    'hex_code' => '',
    '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}}/activities', [
  'body' => '{
  "hex_code": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

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

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

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

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

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

import requests

url = "{{baseUrl}}/activities"

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

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

print(response.json())

library(httr)

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

payload <- "{\n  \"hex_code\": \"\",\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}}/activities")

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  \"hex_code\": \"\",\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/activities') do |req|
  req.body = "{\n  \"hex_code\": \"\",\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}}/activities";

    let payload = json!({
        "hex_code": "",
        "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 '{
  "hex_code": "",
  "name": ""
}' |  \
  http POST {{baseUrl}}/activities \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "hex_code": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/activities

import Foundation

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/activities/:activity_id")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/activities/:activity_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/activities/:activity_id HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/activities/:activity_id'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/activities/:activity_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/activities/:activity_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}}/activities/:activity_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}}/activities/:activity_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}}/activities/:activity_id'};

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

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

const url = '{{baseUrl}}/activities/:activity_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}}/activities/:activity_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}}/activities/:activity_id" in

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

 "{{baseUrl}}/activities/:activity_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}}/activities/:activity_id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/activities/:activity_id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/activities/:activity_id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/activities/:activity_id")

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

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

import requests

url = "{{baseUrl}}/activities/:activity_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/activities/:activity_id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/activities/:activity_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/activities/:activity_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}}/activities/:activity_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}}/activities/:activity_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/activities/:activity_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/activities/:activity_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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/activities/:activity_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  \"hex_code\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/activities/:activity_id" {:content-type :json
                                                                   :form-params {:hex_code ""
                                                                                 :name ""}})

require "http/client"

url = "{{baseUrl}}/activities/:activity_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"hex_code\": \"\",\n  \"name\": \"\"\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}}/activities/:activity_id"),
    Content = new StringContent("{\n  \"hex_code\": \"\",\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}}/activities/:activity_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"hex_code\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/activities/:activity_id"

	payload := strings.NewReader("{\n  \"hex_code\": \"\",\n  \"name\": \"\"\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/activities/:activity_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "hex_code": "",
  "name": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.put("{{baseUrl}}/activities/:activity_id")
  .header("content-type", "application/json")
  .body("{\n  \"hex_code\": \"\",\n  \"name\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/activities/:activity_id',
  headers: {'content-type': 'application/json'},
  data: {hex_code: '', name: ''}
};

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

const url = '{{baseUrl}}/activities/:activity_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"hex_code":"","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}}/activities/:activity_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "hex_code": "",\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  \"hex_code\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/activities/:activity_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/activities/:activity_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({hex_code: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/activities/:activity_id',
  headers: {'content-type': 'application/json'},
  body: {hex_code: '', 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('PUT', '{{baseUrl}}/activities/:activity_id');

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

req.type('json');
req.send({
  hex_code: '',
  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: 'PUT',
  url: '{{baseUrl}}/activities/:activity_id',
  headers: {'content-type': 'application/json'},
  data: {hex_code: '', name: ''}
};

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

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

const url = '{{baseUrl}}/activities/:activity_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"hex_code":"","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 = @{ @"hex_code": @"",
                              @"name": @"" };

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

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

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

 "{{baseUrl}}/activities/:activity_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([
    'hex_code' => '',
    '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('PUT', '{{baseUrl}}/activities/:activity_id', [
  'body' => '{
  "hex_code": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/activities/:activity_id');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'hex_code' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/activities/:activity_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}}/activities/:activity_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "hex_code": "",
  "name": ""
}'

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

import http.client

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

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

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

conn.request("PUT", "/baseUrl/activities/:activity_id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/activities/:activity_id"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/activities/:activity_id"

payload <- "{\n  \"hex_code\": \"\",\n  \"name\": \"\"\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}}/activities/:activity_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  \"hex_code\": \"\",\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.put('/baseUrl/activities/:activity_id') do |req|
  req.body = "{\n  \"hex_code\": \"\",\n  \"name\": \"\"\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}}/activities/:activity_id";

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

    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 '{
  "hex_code": "",
  "name": ""
}' |  \
  http PUT {{baseUrl}}/activities/:activity_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "hex_code": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/activities/:activity_id

import Foundation

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/activities")

require "http/client"

url = "{{baseUrl}}/activities"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/activities")

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

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

import requests

url = "{{baseUrl}}/activities"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/activities

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/offers/:offer_id/changelog")

require "http/client"

url = "{{baseUrl}}/offers/:offer_id/changelog"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/offers/:offer_id/changelog"

	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/offers/:offer_id/changelog HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/offers/:offer_id/changelog'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/:offer_id/changelog")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/:offer_id/changelog');

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}}/offers/:offer_id/changelog'};

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

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

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

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

 "{{baseUrl}}/offers/:offer_id/changelog",
  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}}/offers/:offer_id/changelog');

echo $response->getBody();

setUrl('{{baseUrl}}/offers/:offer_id/changelog');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/:offer_id/changelog' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/:offer_id/changelog' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/offers/:offer_id/changelog")

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

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

import requests

url = "{{baseUrl}}/offers/:offer_id/changelog"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/:offer_id/changelog"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/:offer_id/changelog")

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/offers/:offer_id/changelog') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/offers/:offer_id/changelog

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/offers/:offer_id/changelog

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/:offer_id/changelog")! 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}}/cities/:city_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/cities/:city_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/cities/:city_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/cities/:city_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/cities/:city_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/cities/:city_id"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

GET /baseUrl/cities/:city_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/cities/:city_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/cities/:city_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/cities/:city_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/cities/:city_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/cities/:city_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/cities/:city_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/cities/:city_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/cities/:city_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/cities/:city_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/cities/:city_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/cities/:city_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/cities/:city_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/cities/:city_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/cities/:city_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/cities/:city_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/cities/:city_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/cities/:city_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/cities/:city_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/cities/:city_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/cities/:city_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/cities/:city_id' -Method GET -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/cities/:city_id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/cities/:city_id"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/cities/:city_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/cities/:city_id")

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

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/cities/:city_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/cities/:city_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/cities/:city_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cities/:city_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cities");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/cities" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/cities"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/cities"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/cities");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

GET /baseUrl/cities HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/cities")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/cities"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/cities")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/cities")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/cities');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/cities',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/cities';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/cities',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/cities")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/cities',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/cities',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/cities',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/cities';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/cities" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/cities",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/cities', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/cities');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/cities' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/cities' -Method GET -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/cities", headers=headers)

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

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

import requests

url = "{{baseUrl}}/cities"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/cities') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/cities \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/cities

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cities")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clocking_records/checkout");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clocking_records/checkout" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/clocking_records/checkout"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clocking_records/checkout"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clocking_records/checkout");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clocking_records/checkout"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

POST /baseUrl/clocking_records/checkout HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clocking_records/checkout")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clocking_records/checkout"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/clocking_records/checkout")
  .post(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/clocking_records/checkout")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/clocking_records/checkout');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clocking_records/checkout',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/clocking_records/checkout';
const options = {method: 'POST', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/clocking_records/checkout',
  method: 'POST',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clocking_records/checkout")
  .post(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clocking_records/checkout',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/clocking_records/checkout',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/clocking_records/checkout',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/clocking_records/checkout';
const options = {method: 'POST', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clocking_records/checkout" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/clocking_records/checkout",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/clocking_records/checkout', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/clocking_records/checkout');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clocking_records/checkout' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clocking_records/checkout' -Method POST -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("POST", "/baseUrl/clocking_records/checkout", headers=headers)

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

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

import requests

url = "{{baseUrl}}/clocking_records/checkout"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clocking_records/checkout"

response <- VERB("POST", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clocking_records/checkout")

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

request = Net::HTTP::Post.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.post('/baseUrl/clocking_records/checkout') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http POST {{baseUrl}}/clocking_records/checkout \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/clocking_records/checkout

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clocking_records/checkout")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clocking_records");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clocking_records" {:headers {:x-auth-token "{{apiKey}}"}
                                                             :content-type :json
                                                             :form-params {:checkin_latitude ""
                                                                           :checkin_longitude ""
                                                                           :checkout_latitude ""
                                                                           :checkout_longitude ""
                                                                           :project_id ""}})

require "http/client"

url = "{{baseUrl}}/clocking_records"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\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}}/clocking_records"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\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}}/clocking_records");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}")

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

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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/clocking_records HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "checkin_latitude": "",
  "checkin_longitude": "",
  "checkout_latitude": "",
  "checkout_longitude": "",
  "project_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clocking_records")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clocking_records"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\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  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clocking_records")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/clocking_records")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  checkin_latitude: '',
  checkin_longitude: '',
  checkout_latitude: '',
  checkout_longitude: '',
  project_id: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/clocking_records');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clocking_records',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    checkin_latitude: '',
    checkin_longitude: '',
    checkout_latitude: '',
    checkout_longitude: '',
    project_id: ''
  }
};

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

const url = '{{baseUrl}}/clocking_records';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"checkin_latitude":"","checkin_longitude":"","checkout_latitude":"","checkout_longitude":"","project_id":""}'
};

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}}/clocking_records',
  method: 'POST',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "checkin_latitude": "",\n  "checkin_longitude": "",\n  "checkout_latitude": "",\n  "checkout_longitude": "",\n  "project_id": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clocking_records")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .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/clocking_records',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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({
  checkin_latitude: '',
  checkin_longitude: '',
  checkout_latitude: '',
  checkout_longitude: '',
  project_id: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clocking_records',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {
    checkin_latitude: '',
    checkin_longitude: '',
    checkout_latitude: '',
    checkout_longitude: '',
    project_id: ''
  },
  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}}/clocking_records');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  checkin_latitude: '',
  checkin_longitude: '',
  checkout_latitude: '',
  checkout_longitude: '',
  project_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: 'POST',
  url: '{{baseUrl}}/clocking_records',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    checkin_latitude: '',
    checkin_longitude: '',
    checkout_latitude: '',
    checkout_longitude: '',
    project_id: ''
  }
};

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

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

const url = '{{baseUrl}}/clocking_records';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"checkin_latitude":"","checkin_longitude":"","checkout_latitude":"","checkout_longitude":"","project_id":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"checkin_latitude": @"",
                              @"checkin_longitude": @"",
                              @"checkout_latitude": @"",
                              @"checkout_longitude": @"",
                              @"project_id": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clocking_records"]
                                                       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}}/clocking_records" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}" in

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

 "{{baseUrl}}/clocking_records",
  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([
    'checkin_latitude' => '',
    'checkin_longitude' => '',
    'checkout_latitude' => '',
    'checkout_longitude' => '',
    'project_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/clocking_records', [
  'body' => '{
  "checkin_latitude": "",
  "checkin_longitude": "",
  "checkout_latitude": "",
  "checkout_longitude": "",
  "project_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'checkin_latitude' => '',
  'checkin_longitude' => '',
  'checkout_latitude' => '',
  'checkout_longitude' => '',
  'project_id' => ''
]));

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

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

append(json_encode([
  'checkin_latitude' => '',
  'checkin_longitude' => '',
  'checkout_latitude' => '',
  'checkout_longitude' => '',
  'project_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clocking_records');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clocking_records' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checkin_latitude": "",
  "checkin_longitude": "",
  "checkout_latitude": "",
  "checkout_longitude": "",
  "project_id": ""
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clocking_records' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checkin_latitude": "",
  "checkin_longitude": "",
  "checkout_latitude": "",
  "checkout_longitude": "",
  "project_id": ""
}'

import http.client

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

payload = "{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/clocking_records"

payload = {
    "checkin_latitude": "",
    "checkin_longitude": "",
    "checkout_latitude": "",
    "checkout_longitude": "",
    "project_id": ""
}
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\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/clocking_records') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"checkin_latitude\": \"\",\n  \"checkin_longitude\": \"\",\n  \"checkout_latitude\": \"\",\n  \"checkout_longitude\": \"\",\n  \"project_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "checkin_latitude": "",
        "checkin_longitude": "",
        "checkout_latitude": "",
        "checkout_longitude": "",
        "project_id": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "checkin_latitude": "",
  "checkin_longitude": "",
  "checkout_latitude": "",
  "checkout_longitude": "",
  "project_id": ""
}' |  \
  http POST {{baseUrl}}/clocking_records \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "checkin_latitude": "",\n  "checkin_longitude": "",\n  "checkout_latitude": "",\n  "checkout_longitude": "",\n  "project_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/clocking_records

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "checkin_latitude": "",
  "checkin_longitude": "",
  "checkout_latitude": "",
  "checkout_longitude": "",
  "project_id": ""
] as [String : Any]

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

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/clocking_records/:clocking_record_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/clocking_records/:clocking_record_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/clocking_records/:clocking_record_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clocking_records/:clocking_record_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clocking_records/:clocking_record_id"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

DELETE /baseUrl/clocking_records/:clocking_record_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/clocking_records/:clocking_record_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clocking_records/:clocking_record_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/clocking_records/:clocking_record_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/clocking_records/:clocking_record_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/clocking_records/:clocking_record_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/clocking_records/:clocking_record_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/clocking_records/:clocking_record_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/clocking_records/:clocking_record_id',
  method: 'DELETE',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clocking_records/:clocking_record_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clocking_records/:clocking_record_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/clocking_records/:clocking_record_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/clocking_records/:clocking_record_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/clocking_records/:clocking_record_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/clocking_records/:clocking_record_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clocking_records/:clocking_record_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clocking_records/:clocking_record_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/clocking_records/:clocking_record_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/clocking_records/:clocking_record_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/clocking_records/:clocking_record_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clocking_records/:clocking_record_id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clocking_records/:clocking_record_id' -Method DELETE -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/clocking_records/:clocking_record_id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/clocking_records/:clocking_record_id"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clocking_records/:clocking_record_id"

response <- VERB("DELETE", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clocking_records/:clocking_record_id")

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

request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.delete('/baseUrl/clocking_records/:clocking_record_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/clocking_records/:clocking_record_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/clocking_records/:clocking_record_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clocking_records/:clocking_record_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clocking_records/:clocking_record_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/clocking_records/:clocking_record_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/clocking_records/:clocking_record_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/clocking_records/:clocking_record_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clocking_records/:clocking_record_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clocking_records/:clocking_record_id"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

GET /baseUrl/clocking_records/:clocking_record_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/clocking_records/:clocking_record_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clocking_records/:clocking_record_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/clocking_records/:clocking_record_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/clocking_records/:clocking_record_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/clocking_records/:clocking_record_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clocking_records/:clocking_record_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/clocking_records/:clocking_record_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/clocking_records/:clocking_record_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clocking_records/:clocking_record_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clocking_records/:clocking_record_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/clocking_records/:clocking_record_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clocking_records/:clocking_record_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/clocking_records/:clocking_record_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/clocking_records/:clocking_record_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clocking_records/:clocking_record_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clocking_records/:clocking_record_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/clocking_records/:clocking_record_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/clocking_records/:clocking_record_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/clocking_records/:clocking_record_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clocking_records/:clocking_record_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clocking_records/:clocking_record_id' -Method GET -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/clocking_records/:clocking_record_id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/clocking_records/:clocking_record_id"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clocking_records/:clocking_record_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clocking_records/:clocking_record_id")

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

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/clocking_records/:clocking_record_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/clocking_records/:clocking_record_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/clocking_records/:clocking_record_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clocking_records/:clocking_record_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clocking_records/:clocking_record_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/clocking_records/:clocking_record_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/clocking_records/:clocking_record_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/clocking_records/:clocking_record_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clocking_records/:clocking_record_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clocking_records/:clocking_record_id"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

PUT /baseUrl/clocking_records/:clocking_record_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/clocking_records/:clocking_record_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clocking_records/:clocking_record_id"))
    .header("x-auth-token", "{{apiKey}}")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/clocking_records/:clocking_record_id")
  .put(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/clocking_records/:clocking_record_id")
  .header("x-auth-token", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/clocking_records/:clocking_record_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/clocking_records/:clocking_record_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/clocking_records/:clocking_record_id';
const options = {method: 'PUT', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/clocking_records/:clocking_record_id',
  method: 'PUT',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clocking_records/:clocking_record_id")
  .put(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clocking_records/:clocking_record_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/clocking_records/:clocking_record_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/clocking_records/:clocking_record_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/clocking_records/:clocking_record_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/clocking_records/:clocking_record_id';
const options = {method: 'PUT', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clocking_records/:clocking_record_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clocking_records/:clocking_record_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/clocking_records/:clocking_record_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/clocking_records/:clocking_record_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clocking_records/:clocking_record_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/clocking_records/:clocking_record_id');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clocking_records/:clocking_record_id' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clocking_records/:clocking_record_id' -Method PUT -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("PUT", "/baseUrl/clocking_records/:clocking_record_id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/clocking_records/:clocking_record_id"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clocking_records/:clocking_record_id"

response <- VERB("PUT", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clocking_records/:clocking_record_id")

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

request = Net::HTTP::Put.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.put('/baseUrl/clocking_records/:clocking_record_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/clocking_records/:clocking_record_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/clocking_records/:clocking_record_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clocking_records/:clocking_record_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clocking_records");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/clocking_records" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/clocking_records"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/clocking_records"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clocking_records");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

GET /baseUrl/clocking_records HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/clocking_records")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clocking_records"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/clocking_records")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/clocking_records")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/clocking_records');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clocking_records',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/clocking_records';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/clocking_records',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clocking_records")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clocking_records',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/clocking_records',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/clocking_records',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/clocking_records';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clocking_records" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/clocking_records",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/clocking_records', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/clocking_records');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clocking_records' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clocking_records' -Method GET -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/clocking_records", headers=headers)

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

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

import requests

url = "{{baseUrl}}/clocking_records"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/clocking_records') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/clocking_records \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/clocking_records

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clocking_records")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings" {:headers {:x-auth-token "{{apiKey}}"}
                                                                                                         :content-type :json
                                                                                                         :form-params {:integration_feature_setting_id ""
                                                                                                                       :value ""}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\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}}/companies/:company_id/companies_integration_feature_settings"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\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}}/companies/:company_id/companies_integration_feature_settings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"

	payload := strings.NewReader("{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}")

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

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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/companies/:company_id/companies_integration_feature_settings HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 57

{
  "integration_feature_setting_id": "",
  "value": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\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  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  integration_feature_setting_id: '',
  value: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {integration_feature_setting_id: '', value: ''}
};

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

const url = '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"integration_feature_setting_id":"","value":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings',
  method: 'POST',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "integration_feature_setting_id": "",\n  "value": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .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/companies/:company_id/companies_integration_feature_settings',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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({integration_feature_setting_id: '', value: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {integration_feature_setting_id: '', value: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  integration_feature_setting_id: '',
  value: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {integration_feature_setting_id: '', value: ''}
};

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

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

const url = '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"integration_feature_setting_id":"","value":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"integration_feature_setting_id": @"",
                              @"value": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"]
                                                       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}}/companies/:company_id/companies_integration_feature_settings" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}" in

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

 "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings",
  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([
    'integration_feature_setting_id' => '',
    'value' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings', [
  'body' => '{
  "integration_feature_setting_id": "",
  "value": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/companies_integration_feature_settings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'integration_feature_setting_id' => '',
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/companies/:company_id/companies_integration_feature_settings');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "integration_feature_setting_id": "",
  "value": ""
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "integration_feature_setting_id": "",
  "value": ""
}'

import http.client

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

payload = "{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/companies/:company_id/companies_integration_feature_settings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"

payload = {
    "integration_feature_setting_id": "",
    "value": ""
}
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"

payload <- "{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")

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

request = Net::HTTP::Post.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\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/companies/:company_id/companies_integration_feature_settings') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"integration_feature_setting_id\": \"\",\n  \"value\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "integration_feature_setting_id": "",
        "value": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "integration_feature_setting_id": "",
  "value": ""
}' |  \
  http POST {{baseUrl}}/companies/:company_id/companies_integration_feature_settings \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "integration_feature_setting_id": "",\n  "value": ""\n}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/companies_integration_feature_settings

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "integration_feature_setting_id": "",
  "value": ""
] as [String : Any]

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

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/companies/:company_id/integration_settings" {:headers {:x-auth-token "{{apiKey}}"}
                                                                                       :content-type :json
                                                                                       :form-params {:integration_setting_id ""
                                                                                                     :value ""}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/integration_settings"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\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}}/companies/:company_id/integration_settings"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\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}}/companies/:company_id/integration_settings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:company_id/integration_settings"

	payload := strings.NewReader("{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}")

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

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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/companies/:company_id/integration_settings HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "integration_setting_id": "",
  "value": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/companies/:company_id/integration_settings")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/integration_settings"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\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  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/integration_settings")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/companies/:company_id/integration_settings")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  integration_setting_id: '',
  value: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/companies/:company_id/integration_settings');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:company_id/integration_settings',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {integration_setting_id: '', value: ''}
};

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

const url = '{{baseUrl}}/companies/:company_id/integration_settings';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"integration_setting_id":"","value":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/companies/:company_id/integration_settings',
  method: 'POST',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "integration_setting_id": "",\n  "value": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/integration_settings")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .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/companies/:company_id/integration_settings',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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({integration_setting_id: '', value: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:company_id/integration_settings',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {integration_setting_id: '', value: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/companies/:company_id/integration_settings');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  integration_setting_id: '',
  value: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:company_id/integration_settings',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {integration_setting_id: '', value: ''}
};

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

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

const url = '{{baseUrl}}/companies/:company_id/integration_settings';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"integration_setting_id":"","value":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"integration_setting_id": @"",
                              @"value": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/integration_settings"]
                                                       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}}/companies/:company_id/integration_settings" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}" in

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

 "{{baseUrl}}/companies/:company_id/integration_settings",
  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([
    'integration_setting_id' => '',
    'value' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/companies/:company_id/integration_settings', [
  'body' => '{
  "integration_setting_id": "",
  "value": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/integration_settings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'integration_setting_id' => '',
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/companies/:company_id/integration_settings');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/integration_settings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "integration_setting_id": "",
  "value": ""
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/integration_settings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "integration_setting_id": "",
  "value": ""
}'

import http.client

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

payload = "{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/companies/:company_id/integration_settings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/companies/:company_id/integration_settings"

payload = {
    "integration_setting_id": "",
    "value": ""
}
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/integration_settings"

payload <- "{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/integration_settings")

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

request = Net::HTTP::Post.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\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/companies/:company_id/integration_settings') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"integration_setting_id\": \"\",\n  \"value\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "integration_setting_id": "",
        "value": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "integration_setting_id": "",
  "value": ""
}' |  \
  http POST {{baseUrl}}/companies/:company_id/integration_settings \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "integration_setting_id": "",\n  "value": ""\n}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/integration_settings

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "integration_setting_id": "",
  "value": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/integration_settings")! 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}}/companies/:company_id/price_margins/:price_margins_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id" {:headers {:x-auth-token "{{apiKey}}"}
                                                                                                  :content-type :json
                                                                                                  :form-params {:id ""
                                                                                                                :value ""}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"value\": \"\"\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}}/companies/:company_id/price_margins/:price_margins_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"id\": \"\",\n  \"value\": \"\"\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}}/companies/:company_id/price_margins/:price_margins_id");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"value\": \"\"\n}")

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

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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/companies/:company_id/price_margins/:price_margins_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 29

{
  "id": "",
  "value": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"value\": \"\"\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  \"id\": \"\",\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"value\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  value: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {id: '', value: ''}
};

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

const url = '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"id":"","value":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id',
  method: 'POST',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "value": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .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/companies/:company_id/price_margins/:price_margins_id',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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({id: '', value: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {id: '', value: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: '',
  value: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {id: '', value: ''}
};

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

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

const url = '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"id":"","value":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"id": @"",
                              @"value": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/price_margins/:price_margins_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}}/companies/:company_id/price_margins/:price_margins_id" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"value\": \"\"\n}" in

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

 "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_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([
    'id' => '',
    'value' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id', [
  'body' => '{
  "id": "",
  "value": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'id' => '',
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "value": ""
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "value": ""
}'

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"value\": \"\"\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/companies/:company_id/price_margins/:price_margins_id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"

payload = {
    "id": "",
    "value": ""
}
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"

payload <- "{\n  \"id\": \"\",\n  \"value\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")

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

request = Net::HTTP::Post.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"\",\n  \"value\": \"\"\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/companies/:company_id/price_margins/:price_margins_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"id\": \"\",\n  \"value\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "id": "",
        "value": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "id": "",
  "value": ""
}' |  \
  http POST {{baseUrl}}/companies/:company_id/price_margins/:price_margins_id \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "value": ""\n}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/price_margins/:price_margins_id

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "id": "",
  "value": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

DELETE /baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/integration_settings/:companies_integration_setting_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  method: 'DELETE',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id' -Method DELETE -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"

response <- VERB("DELETE", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")

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

request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.delete('/baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id" {:headers {:x-auth-token "{{apiKey}}"}
                                                                                                    :query-params {:price_margin_id ""}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id="
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id="),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id="

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

DELETE /baseUrl/companies/:company_id/price_margins/:price_margins_id?price_margin_id= HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id="))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id',
  params: {price_margin_id: ''},
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=',
  method: 'DELETE',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/price_margins/:price_margins_id?price_margin_id=',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/price_margins/:price_margins_id',
  qs: {price_margin_id: ''},
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');

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

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/price_margins/:price_margins_id',
  params: {price_margin_id: ''},
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');
$request->setMethod(HTTP_METH_DELETE);

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

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'price_margin_id' => ''
]));

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=' -Method DELETE -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/companies/:company_id/price_margins/:price_margins_id?price_margin_id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"

querystring = {"price_margin_id":""}

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.delete(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"

queryString <- list(price_margin_id = "")

response <- VERB("DELETE", url, query = queryString, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=")

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

request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.delete('/baseUrl/companies/:company_id/price_margins/:price_margins_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.params['price_margin_id'] = ''
end

puts response.status
puts response.body

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

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=' \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id='

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id?price_margin_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

DELETE /baseUrl/companies/:company_id/form_templates/:form_template_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/form_templates/:form_template_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/form_templates/:form_template_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/form_templates/:form_template_id',
  method: 'DELETE',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/form_templates/:form_template_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/form_templates/:form_template_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/form_templates/:form_template_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/form_templates/:form_template_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/form_templates/:form_template_id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/companies/:company_id/form_templates/:form_template_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id' -Method DELETE -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/companies/:company_id/form_templates/:form_template_id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id"

response <- VERB("DELETE", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id")

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

request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.delete('/baseUrl/companies/:company_id/form_templates/:form_template_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/companies/:company_id/form_templates/:form_template_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/form_templates/:form_template_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/companies/:company_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:company_id"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

GET /baseUrl/companies/:company_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/companies/:company_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/companies/:company_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/companies/:company_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/companies/:company_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/companies/:company_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id' -Method GET -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/companies/:company_id"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id")

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

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/companies/:company_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/companies/:company_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

PUT /baseUrl/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"))
    .header("x-auth-token", "{{apiKey}}")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")
  .put(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")
  .header("x-auth-token", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id';
const options = {method: 'PUT', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  method: 'PUT',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")
  .put(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id';
const options = {method: 'PUT', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id' -Method PUT -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("PUT", "/baseUrl/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"

response <- VERB("PUT", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")

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

request = Net::HTTP::Put.new(url)
request["x-auth-token"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.put('/baseUrl/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"

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

	req.Header.Add("x-auth-token", "{{apiKey}}")

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

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

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

}

PUT /baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"))
    .header("x-auth-token", "{{apiKey}}")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .put(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .header("x-auth-token", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id';
const options = {method: 'PUT', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  method: 'PUT',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .put(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id';
const options = {method: 'PUT', headers: {'x-auth-token': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

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

 "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id' -Method PUT -Headers $headers

import http.client

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

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("PUT", "/baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"

headers = {"x-auth-token": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"

response <- VERB("PUT", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")

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

request = Net::HTTP::Put.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT {{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id" {:headers {:x-auth-token "{{apiKey}}"}
                                                                                                  :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id="
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id="),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/:company_id/form_templates/:form_template_id?id= HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id="))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/form_templates/:form_template_id?id=")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/form_templates/:form_template_id?id=');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id',
  params: {id: ''},
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/form_templates/:form_template_id?id=',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/form_templates/:form_template_id?id=',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/form_templates/:form_template_id',
  qs: {id: ''},
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id');

req.query({
  id: ''
});

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/form_templates/:form_template_id',
  params: {id: ''},
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/form_templates/:form_template_id');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'id' => ''
]);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:company_id/form_templates/:form_template_id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id/form_templates/:form_template_id?id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id"

querystring = {"id":""}

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id"

queryString <- list(id = "")

response <- VERB("GET", url, query = queryString, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/:company_id/form_templates/:form_template_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id";

    let querystring = [
        ("id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=' \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id='

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/form_templates/:form_template_id?id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/integration_settings/:companies_integration_setting_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/integration_settings/:companies_integration_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/:company_id/integration_settings/:companies_integration_setting_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/integration_settings/:companies_integration_setting_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:company_id/form_templates/" {:headers {:x-auth-token "{{apiKey}}"}
                                                                                 :query-params {:form_template_id ""}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/form_templates/?form_template_id="
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/form_templates/?form_template_id="),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:company_id/form_templates/?form_template_id="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/:company_id/form_templates/?form_template_id= HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/form_templates/?form_template_id="))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/form_templates/?form_template_id=")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/form_templates/?form_template_id=');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id/form_templates/',
  params: {form_template_id: ''},
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/form_templates/?form_template_id=',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/form_templates/?form_template_id=',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/form_templates/',
  qs: {form_template_id: ''},
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id/form_templates/');

req.query({
  form_template_id: ''
});

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/form_templates/',
  params: {form_template_id: ''},
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/form_templates/?form_template_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/form_templates/');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'form_template_id' => ''
]);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:company_id/form_templates/');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'form_template_id' => ''
]));

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id/form_templates/?form_template_id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:company_id/form_templates/"

querystring = {"form_template_id":""}

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/form_templates/"

queryString <- list(form_template_id = "")

response <- VERB("GET", url, query = queryString, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/:company_id/form_templates/') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.params['form_template_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/form_templates/";

    let querystring = [
        ("form_template_id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=' \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/companies/:company_id/form_templates/?form_template_id='

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/form_templates/?form_template_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/integration_settings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:company_id/integration_settings" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/integration_settings"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/integration_settings"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/integration_settings");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:company_id/integration_settings"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/:company_id/integration_settings HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id/integration_settings")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/integration_settings"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/integration_settings")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id/integration_settings")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/integration_settings');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id/integration_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:company_id/integration_settings';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/integration_settings',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/integration_settings")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/integration_settings',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/integration_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id/integration_settings');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/integration_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:company_id/integration_settings';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/integration_settings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/integration_settings" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:company_id/integration_settings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/:company_id/integration_settings', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/integration_settings');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:company_id/integration_settings');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/integration_settings' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/integration_settings' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id/integration_settings", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:company_id/integration_settings"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/integration_settings"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/integration_settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/:company_id/integration_settings') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/integration_settings";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies/:company_id/integration_settings \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/integration_settings

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/integration_settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/:company_id/price_margins/:price_margins_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/price_margins/:price_margins_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/price_margins/:price_margins_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/price_margins/:price_margins_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/price_margins/:price_margins_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/price_margins/:price_margins_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/price_margins/:price_margins_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id/price_margins/:price_margins_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/:company_id/price_margins/:price_margins_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies/:company_id/price_margins/:price_margins_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/price_margins/:price_margins_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/price_margins/:price_margins_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/integration_feature_settings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:company_id/integration_feature_settings" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/integration_feature_settings"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/integration_feature_settings"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/integration_feature_settings");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:company_id/integration_feature_settings"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/:company_id/integration_feature_settings HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id/integration_feature_settings")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/integration_feature_settings"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/integration_feature_settings")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id/integration_feature_settings")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/integration_feature_settings');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id/integration_feature_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:company_id/integration_feature_settings';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/integration_feature_settings',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/integration_feature_settings")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/integration_feature_settings',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/integration_feature_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id/integration_feature_settings');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/integration_feature_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:company_id/integration_feature_settings';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/integration_feature_settings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/integration_feature_settings" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:company_id/integration_feature_settings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/:company_id/integration_feature_settings', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/integration_feature_settings');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:company_id/integration_feature_settings');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/integration_feature_settings' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/integration_feature_settings' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id/integration_feature_settings", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:company_id/integration_feature_settings"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/integration_feature_settings"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/integration_feature_settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/:company_id/integration_feature_settings') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/integration_feature_settings";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies/:company_id/integration_feature_settings \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/integration_feature_settings

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/integration_feature_settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/:company_id/companies_integration_feature_settings HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/companies_integration_feature_settings")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/companies_integration_feature_settings');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/companies_integration_feature_settings',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/companies_integration_feature_settings',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/companies_integration_feature_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/companies_integration_feature_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/companies_integration_feature_settings');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:company_id/companies_integration_feature_settings');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id/companies_integration_feature_settings", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/:company_id/companies_integration_feature_settings') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies/:company_id/companies_integration_feature_settings \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/companies_integration_feature_settings

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/:company_id/integration_feature_settings/:integration_feature_setting_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/integration_feature_settings/:integration_feature_setting_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id/integration_feature_settings/:integration_feature_setting_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/:company_id/integration_feature_settings/:integration_feature_setting_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/integration_feature_settings/:integration_feature_setting_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/subscription_self_service");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/subscription_self_service" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/subscription_self_service"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/subscription_self_service"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/subscription_self_service");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/subscription_self_service"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/subscription_self_service HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/subscription_self_service")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/subscription_self_service"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/subscription_self_service")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/subscription_self_service")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/subscription_self_service');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/subscription_self_service',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/subscription_self_service';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/subscription_self_service',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/subscription_self_service")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/subscription_self_service',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/subscription_self_service',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/subscription_self_service');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/subscription_self_service',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/subscription_self_service';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/subscription_self_service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/subscription_self_service" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/subscription_self_service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/subscription_self_service', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/subscription_self_service');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/subscription_self_service');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/subscription_self_service' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/subscription_self_service' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/subscription_self_service", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/subscription_self_service"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/subscription_self_service"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/subscription_self_service")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/subscription_self_service') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/subscription_self_service";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies/subscription_self_service \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/subscription_self_service

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/subscription_self_service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:company_id/companies_integration_feature_settings/:c_integration_feature_setting_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies_vendors");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/companies_vendors" {:headers {:x-auth-token "{{apiKey}}"}
                                                              :content-type :json
                                                              :form-params {:company_id ""
                                                                            :delivery_price ""
                                                                            :free_delivery_price ""
                                                                            :is_active false
                                                                            :password ""
                                                                            :receive_automatic_price_files false
                                                                            :receive_invoice_mails false
                                                                            :reviewed false
                                                                            :use_price_files false
                                                                            :username ""
                                                                            :vendor_account_reference ""
                                                                            :vendor_department_id ""
                                                                            :vendor_email ""
                                                                            :vendor_id ""
                                                                            :vendor_name ""}})

require "http/client"

url = "{{baseUrl}}/companies_vendors"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_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}}/companies_vendors"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_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}}/companies_vendors");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies_vendors"

	payload := strings.NewReader("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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/companies_vendors HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 384

{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/companies_vendors")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies_vendors"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_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  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/companies_vendors")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/companies_vendors")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  company_id: '',
  delivery_price: '',
  free_delivery_price: '',
  is_active: false,
  password: '',
  receive_automatic_price_files: false,
  receive_invoice_mails: false,
  reviewed: false,
  use_price_files: false,
  username: '',
  vendor_account_reference: '',
  vendor_department_id: '',
  vendor_email: '',
  vendor_id: '',
  vendor_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}}/companies_vendors');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies_vendors',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    company_id: '',
    delivery_price: '',
    free_delivery_price: '',
    is_active: false,
    password: '',
    receive_automatic_price_files: false,
    receive_invoice_mails: false,
    reviewed: false,
    use_price_files: false,
    username: '',
    vendor_account_reference: '',
    vendor_department_id: '',
    vendor_email: '',
    vendor_id: '',
    vendor_name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies_vendors';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"company_id":"","delivery_price":"","free_delivery_price":"","is_active":false,"password":"","receive_automatic_price_files":false,"receive_invoice_mails":false,"reviewed":false,"use_price_files":false,"username":"","vendor_account_reference":"","vendor_department_id":"","vendor_email":"","vendor_id":"","vendor_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}}/companies_vendors',
  method: 'POST',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "company_id": "",\n  "delivery_price": "",\n  "free_delivery_price": "",\n  "is_active": false,\n  "password": "",\n  "receive_automatic_price_files": false,\n  "receive_invoice_mails": false,\n  "reviewed": false,\n  "use_price_files": false,\n  "username": "",\n  "vendor_account_reference": "",\n  "vendor_department_id": "",\n  "vendor_email": "",\n  "vendor_id": "",\n  "vendor_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  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/companies_vendors")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .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/companies_vendors',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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({
  company_id: '',
  delivery_price: '',
  free_delivery_price: '',
  is_active: false,
  password: '',
  receive_automatic_price_files: false,
  receive_invoice_mails: false,
  reviewed: false,
  use_price_files: false,
  username: '',
  vendor_account_reference: '',
  vendor_department_id: '',
  vendor_email: '',
  vendor_id: '',
  vendor_name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies_vendors',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {
    company_id: '',
    delivery_price: '',
    free_delivery_price: '',
    is_active: false,
    password: '',
    receive_automatic_price_files: false,
    receive_invoice_mails: false,
    reviewed: false,
    use_price_files: false,
    username: '',
    vendor_account_reference: '',
    vendor_department_id: '',
    vendor_email: '',
    vendor_id: '',
    vendor_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}}/companies_vendors');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  company_id: '',
  delivery_price: '',
  free_delivery_price: '',
  is_active: false,
  password: '',
  receive_automatic_price_files: false,
  receive_invoice_mails: false,
  reviewed: false,
  use_price_files: false,
  username: '',
  vendor_account_reference: '',
  vendor_department_id: '',
  vendor_email: '',
  vendor_id: '',
  vendor_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}}/companies_vendors',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    company_id: '',
    delivery_price: '',
    free_delivery_price: '',
    is_active: false,
    password: '',
    receive_automatic_price_files: false,
    receive_invoice_mails: false,
    reviewed: false,
    use_price_files: false,
    username: '',
    vendor_account_reference: '',
    vendor_department_id: '',
    vendor_email: '',
    vendor_id: '',
    vendor_name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies_vendors';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"company_id":"","delivery_price":"","free_delivery_price":"","is_active":false,"password":"","receive_automatic_price_files":false,"receive_invoice_mails":false,"reviewed":false,"use_price_files":false,"username":"","vendor_account_reference":"","vendor_department_id":"","vendor_email":"","vendor_id":"","vendor_name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"company_id": @"",
                              @"delivery_price": @"",
                              @"free_delivery_price": @"",
                              @"is_active": @NO,
                              @"password": @"",
                              @"receive_automatic_price_files": @NO,
                              @"receive_invoice_mails": @NO,
                              @"reviewed": @NO,
                              @"use_price_files": @NO,
                              @"username": @"",
                              @"vendor_account_reference": @"",
                              @"vendor_department_id": @"",
                              @"vendor_email": @"",
                              @"vendor_id": @"",
                              @"vendor_name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies_vendors"]
                                                       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}}/companies_vendors" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies_vendors",
  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([
    'company_id' => '',
    'delivery_price' => '',
    'free_delivery_price' => '',
    'is_active' => null,
    'password' => '',
    'receive_automatic_price_files' => null,
    'receive_invoice_mails' => null,
    'reviewed' => null,
    'use_price_files' => null,
    'username' => '',
    'vendor_account_reference' => '',
    'vendor_department_id' => '',
    'vendor_email' => '',
    'vendor_id' => '',
    'vendor_name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/companies_vendors', [
  'body' => '{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies_vendors');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'company_id' => '',
  'delivery_price' => '',
  'free_delivery_price' => '',
  'is_active' => null,
  'password' => '',
  'receive_automatic_price_files' => null,
  'receive_invoice_mails' => null,
  'reviewed' => null,
  'use_price_files' => null,
  'username' => '',
  'vendor_account_reference' => '',
  'vendor_department_id' => '',
  'vendor_email' => '',
  'vendor_id' => '',
  'vendor_name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'company_id' => '',
  'delivery_price' => '',
  'free_delivery_price' => '',
  'is_active' => null,
  'password' => '',
  'receive_automatic_price_files' => null,
  'receive_invoice_mails' => null,
  'reviewed' => null,
  'use_price_files' => null,
  'username' => '',
  'vendor_account_reference' => '',
  'vendor_department_id' => '',
  'vendor_email' => '',
  'vendor_id' => '',
  'vendor_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/companies_vendors');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies_vendors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies_vendors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/companies_vendors", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies_vendors"

payload = {
    "company_id": "",
    "delivery_price": "",
    "free_delivery_price": "",
    "is_active": False,
    "password": "",
    "receive_automatic_price_files": False,
    "receive_invoice_mails": False,
    "reviewed": False,
    "use_price_files": False,
    "username": "",
    "vendor_account_reference": "",
    "vendor_department_id": "",
    "vendor_email": "",
    "vendor_id": "",
    "vendor_name": ""
}
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies_vendors"

payload <- "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies_vendors")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_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/companies_vendors') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies_vendors";

    let payload = json!({
        "company_id": "",
        "delivery_price": "",
        "free_delivery_price": "",
        "is_active": false,
        "password": "",
        "receive_automatic_price_files": false,
        "receive_invoice_mails": false,
        "reviewed": false,
        "use_price_files": false,
        "username": "",
        "vendor_account_reference": "",
        "vendor_department_id": "",
        "vendor_email": "",
        "vendor_id": "",
        "vendor_name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}' |  \
  http POST {{baseUrl}}/companies_vendors \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "company_id": "",\n  "delivery_price": "",\n  "free_delivery_price": "",\n  "is_active": false,\n  "password": "",\n  "receive_automatic_price_files": false,\n  "receive_invoice_mails": false,\n  "reviewed": false,\n  "use_price_files": false,\n  "username": "",\n  "vendor_account_reference": "",\n  "vendor_department_id": "",\n  "vendor_email": "",\n  "vendor_id": "",\n  "vendor_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/companies_vendors

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies_vendors")! 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}}/companies_vendors/bulkDelete");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"id\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/companies_vendors/bulkDelete" {:headers {:x-auth-token "{{apiKey}}"}
                                                                           :content-type :json
                                                                           :form-params {:id []}})

require "http/client"

url = "{{baseUrl}}/companies_vendors/bulkDelete"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": []\n}"

response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/companies_vendors/bulkDelete"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"id\": []\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}}/companies_vendors/bulkDelete");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies_vendors/bulkDelete"

	payload := strings.NewReader("{\n  \"id\": []\n}")

	req, _ := http.NewRequest("DELETE", url, payload)

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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))

}

DELETE /baseUrl/companies_vendors/bulkDelete HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 14

{
  "id": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/companies_vendors/bulkDelete")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies_vendors/bulkDelete"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("{\n  \"id\": []\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  \"id\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/companies_vendors/bulkDelete")
  .delete(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/companies_vendors/bulkDelete")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"id\": []\n}")
  .asString();

const data = JSON.stringify({
  id: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/companies_vendors/bulkDelete');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/companies_vendors/bulkDelete',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {id: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies_vendors/bulkDelete';
const options = {
  method: 'DELETE',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"id":[]}'
};

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}}/companies_vendors/bulkDelete',
  method: 'DELETE',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/companies_vendors/bulkDelete")
  .delete(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies_vendors/bulkDelete',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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({id: []}));
req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/companies_vendors/bulkDelete',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {id: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/companies_vendors/bulkDelete');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  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}}/companies_vendors/bulkDelete',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {id: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies_vendors/bulkDelete';
const options = {
  method: 'DELETE',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"id":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"id": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies_vendors/bulkDelete"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/companies_vendors/bulkDelete" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": []\n}" in

Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies_vendors/bulkDelete",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/companies_vendors/bulkDelete', [
  'body' => '{
  "id": []
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies_vendors/bulkDelete');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/companies_vendors/bulkDelete');
$request->setRequestMethod('DELETE');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies_vendors/bulkDelete' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "id": []
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies_vendors/bulkDelete' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "id": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": []\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("DELETE", "/baseUrl/companies_vendors/bulkDelete", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies_vendors/bulkDelete"

payload = { "id": [] }
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.delete(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies_vendors/bulkDelete"

payload <- "{\n  \"id\": []\n}"

encode <- "json"

response <- VERB("DELETE", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies_vendors/bulkDelete")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": []\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.delete('/baseUrl/companies_vendors/bulkDelete') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"id\": []\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}}/companies_vendors/bulkDelete";

    let payload = json!({"id": ()});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "id": []
}' |  \
  http DELETE {{baseUrl}}/companies_vendors/bulkDelete \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": []\n}' \
  --output-document \
  - {{baseUrl}}/companies_vendors/bulkDelete

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["id": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies_vendors/bulkDelete")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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}}/companies_vendors/:companies_vendor_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/companies_vendors/:companies_vendor_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies_vendors/:companies_vendor_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/companies_vendors/:companies_vendor_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies_vendors/:companies_vendor_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies_vendors/:companies_vendor_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/companies_vendors/:companies_vendor_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies_vendors/:companies_vendor_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies_vendors/:companies_vendor_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies_vendors/:companies_vendor_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/companies_vendors/:companies_vendor_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies_vendors/:companies_vendor_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies_vendors/:companies_vendor_id',
  method: 'DELETE',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies_vendors/:companies_vendor_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies_vendors/:companies_vendor_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/companies_vendors/:companies_vendor_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies_vendors/:companies_vendor_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies_vendors/:companies_vendor_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies_vendors/:companies_vendor_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies_vendors/:companies_vendor_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies_vendors/:companies_vendor_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/companies_vendors/:companies_vendor_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies_vendors/:companies_vendor_id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies_vendors/:companies_vendor_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies_vendors/:companies_vendor_id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies_vendors/:companies_vendor_id' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/companies_vendors/:companies_vendor_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies_vendors/:companies_vendor_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies_vendors/:companies_vendor_id"

response <- VERB("DELETE", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies_vendors/:companies_vendor_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/companies_vendors/:companies_vendor_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies_vendors/:companies_vendor_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/companies_vendors/:companies_vendor_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies_vendors/:companies_vendor_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies_vendors/:companies_vendor_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies_vendors/:companies_vendor_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/companies_vendors/:companies_vendor_id" {:headers {:x-auth-token "{{apiKey}}"}
                                                                                  :content-type :json
                                                                                  :form-params {:company_id ""
                                                                                                :delivery_price ""
                                                                                                :free_delivery_price ""
                                                                                                :is_active false
                                                                                                :password ""
                                                                                                :receive_automatic_price_files false
                                                                                                :receive_invoice_mails false
                                                                                                :reviewed false
                                                                                                :use_price_files false
                                                                                                :username ""
                                                                                                :vendor_account_reference ""
                                                                                                :vendor_department_id ""
                                                                                                :vendor_email ""
                                                                                                :vendor_id ""
                                                                                                :vendor_name ""}})

require "http/client"

url = "{{baseUrl}}/companies_vendors/:companies_vendor_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\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}}/companies_vendors/:companies_vendor_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_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}}/companies_vendors/:companies_vendor_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies_vendors/:companies_vendor_id"

	payload := strings.NewReader("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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/companies_vendors/:companies_vendor_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 384

{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies_vendors/:companies_vendor_id"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_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  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .put(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  company_id: '',
  delivery_price: '',
  free_delivery_price: '',
  is_active: false,
  password: '',
  receive_automatic_price_files: false,
  receive_invoice_mails: false,
  reviewed: false,
  use_price_files: false,
  username: '',
  vendor_account_reference: '',
  vendor_department_id: '',
  vendor_email: '',
  vendor_id: '',
  vendor_name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/companies_vendors/:companies_vendor_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/companies_vendors/:companies_vendor_id',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    company_id: '',
    delivery_price: '',
    free_delivery_price: '',
    is_active: false,
    password: '',
    receive_automatic_price_files: false,
    receive_invoice_mails: false,
    reviewed: false,
    use_price_files: false,
    username: '',
    vendor_account_reference: '',
    vendor_department_id: '',
    vendor_email: '',
    vendor_id: '',
    vendor_name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies_vendors/:companies_vendor_id';
const options = {
  method: 'PUT',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"company_id":"","delivery_price":"","free_delivery_price":"","is_active":false,"password":"","receive_automatic_price_files":false,"receive_invoice_mails":false,"reviewed":false,"use_price_files":false,"username":"","vendor_account_reference":"","vendor_department_id":"","vendor_email":"","vendor_id":"","vendor_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}}/companies_vendors/:companies_vendor_id',
  method: 'PUT',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "company_id": "",\n  "delivery_price": "",\n  "free_delivery_price": "",\n  "is_active": false,\n  "password": "",\n  "receive_automatic_price_files": false,\n  "receive_invoice_mails": false,\n  "reviewed": false,\n  "use_price_files": false,\n  "username": "",\n  "vendor_account_reference": "",\n  "vendor_department_id": "",\n  "vendor_email": "",\n  "vendor_id": "",\n  "vendor_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  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .put(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .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/companies_vendors/:companies_vendor_id',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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({
  company_id: '',
  delivery_price: '',
  free_delivery_price: '',
  is_active: false,
  password: '',
  receive_automatic_price_files: false,
  receive_invoice_mails: false,
  reviewed: false,
  use_price_files: false,
  username: '',
  vendor_account_reference: '',
  vendor_department_id: '',
  vendor_email: '',
  vendor_id: '',
  vendor_name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/companies_vendors/:companies_vendor_id',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {
    company_id: '',
    delivery_price: '',
    free_delivery_price: '',
    is_active: false,
    password: '',
    receive_automatic_price_files: false,
    receive_invoice_mails: false,
    reviewed: false,
    use_price_files: false,
    username: '',
    vendor_account_reference: '',
    vendor_department_id: '',
    vendor_email: '',
    vendor_id: '',
    vendor_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('PUT', '{{baseUrl}}/companies_vendors/:companies_vendor_id');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  company_id: '',
  delivery_price: '',
  free_delivery_price: '',
  is_active: false,
  password: '',
  receive_automatic_price_files: false,
  receive_invoice_mails: false,
  reviewed: false,
  use_price_files: false,
  username: '',
  vendor_account_reference: '',
  vendor_department_id: '',
  vendor_email: '',
  vendor_id: '',
  vendor_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: 'PUT',
  url: '{{baseUrl}}/companies_vendors/:companies_vendor_id',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    company_id: '',
    delivery_price: '',
    free_delivery_price: '',
    is_active: false,
    password: '',
    receive_automatic_price_files: false,
    receive_invoice_mails: false,
    reviewed: false,
    use_price_files: false,
    username: '',
    vendor_account_reference: '',
    vendor_department_id: '',
    vendor_email: '',
    vendor_id: '',
    vendor_name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies_vendors/:companies_vendor_id';
const options = {
  method: 'PUT',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"company_id":"","delivery_price":"","free_delivery_price":"","is_active":false,"password":"","receive_automatic_price_files":false,"receive_invoice_mails":false,"reviewed":false,"use_price_files":false,"username":"","vendor_account_reference":"","vendor_department_id":"","vendor_email":"","vendor_id":"","vendor_name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"company_id": @"",
                              @"delivery_price": @"",
                              @"free_delivery_price": @"",
                              @"is_active": @NO,
                              @"password": @"",
                              @"receive_automatic_price_files": @NO,
                              @"receive_invoice_mails": @NO,
                              @"reviewed": @NO,
                              @"use_price_files": @NO,
                              @"username": @"",
                              @"vendor_account_reference": @"",
                              @"vendor_department_id": @"",
                              @"vendor_email": @"",
                              @"vendor_id": @"",
                              @"vendor_name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies_vendors/:companies_vendor_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}}/companies_vendors/:companies_vendor_id" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies_vendors/:companies_vendor_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([
    'company_id' => '',
    'delivery_price' => '',
    'free_delivery_price' => '',
    'is_active' => null,
    'password' => '',
    'receive_automatic_price_files' => null,
    'receive_invoice_mails' => null,
    'reviewed' => null,
    'use_price_files' => null,
    'username' => '',
    'vendor_account_reference' => '',
    'vendor_department_id' => '',
    'vendor_email' => '',
    'vendor_id' => '',
    'vendor_name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/companies_vendors/:companies_vendor_id', [
  'body' => '{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies_vendors/:companies_vendor_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'company_id' => '',
  'delivery_price' => '',
  'free_delivery_price' => '',
  'is_active' => null,
  'password' => '',
  'receive_automatic_price_files' => null,
  'receive_invoice_mails' => null,
  'reviewed' => null,
  'use_price_files' => null,
  'username' => '',
  'vendor_account_reference' => '',
  'vendor_department_id' => '',
  'vendor_email' => '',
  'vendor_id' => '',
  'vendor_name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'company_id' => '',
  'delivery_price' => '',
  'free_delivery_price' => '',
  'is_active' => null,
  'password' => '',
  'receive_automatic_price_files' => null,
  'receive_invoice_mails' => null,
  'reviewed' => null,
  'use_price_files' => null,
  'username' => '',
  'vendor_account_reference' => '',
  'vendor_department_id' => '',
  'vendor_email' => '',
  'vendor_id' => '',
  'vendor_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/companies_vendors/:companies_vendor_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies_vendors/:companies_vendor_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies_vendors/:companies_vendor_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/companies_vendors/:companies_vendor_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies_vendors/:companies_vendor_id"

payload = {
    "company_id": "",
    "delivery_price": "",
    "free_delivery_price": "",
    "is_active": False,
    "password": "",
    "receive_automatic_price_files": False,
    "receive_invoice_mails": False,
    "reviewed": False,
    "use_price_files": False,
    "username": "",
    "vendor_account_reference": "",
    "vendor_department_id": "",
    "vendor_email": "",
    "vendor_id": "",
    "vendor_name": ""
}
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies_vendors/:companies_vendor_id"

payload <- "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies_vendors/:companies_vendor_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_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.put('/baseUrl/companies_vendors/:companies_vendor_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"company_id\": \"\",\n  \"delivery_price\": \"\",\n  \"free_delivery_price\": \"\",\n  \"is_active\": false,\n  \"password\": \"\",\n  \"receive_automatic_price_files\": false,\n  \"receive_invoice_mails\": false,\n  \"reviewed\": false,\n  \"use_price_files\": false,\n  \"username\": \"\",\n  \"vendor_account_reference\": \"\",\n  \"vendor_department_id\": \"\",\n  \"vendor_email\": \"\",\n  \"vendor_id\": \"\",\n  \"vendor_name\": \"\"\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}}/companies_vendors/:companies_vendor_id";

    let payload = json!({
        "company_id": "",
        "delivery_price": "",
        "free_delivery_price": "",
        "is_active": false,
        "password": "",
        "receive_automatic_price_files": false,
        "receive_invoice_mails": false,
        "reviewed": false,
        "use_price_files": false,
        "username": "",
        "vendor_account_reference": "",
        "vendor_department_id": "",
        "vendor_email": "",
        "vendor_id": "",
        "vendor_name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());
    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 '{
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
}' |  \
  http PUT {{baseUrl}}/companies_vendors/:companies_vendor_id \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "company_id": "",\n  "delivery_price": "",\n  "free_delivery_price": "",\n  "is_active": false,\n  "password": "",\n  "receive_automatic_price_files": false,\n  "receive_invoice_mails": false,\n  "reviewed": false,\n  "use_price_files": false,\n  "username": "",\n  "vendor_account_reference": "",\n  "vendor_department_id": "",\n  "vendor_email": "",\n  "vendor_id": "",\n  "vendor_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/companies_vendors/:companies_vendor_id

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "company_id": "",
  "delivery_price": "",
  "free_delivery_price": "",
  "is_active": false,
  "password": "",
  "receive_automatic_price_files": false,
  "receive_invoice_mails": false,
  "reviewed": false,
  "use_price_files": false,
  "username": "",
  "vendor_account_reference": "",
  "vendor_department_id": "",
  "vendor_email": "",
  "vendor_id": "",
  "vendor_name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies_vendors/:companies_vendor_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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies_vendors/:companies_vendor_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies_vendors/:companies_vendor_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies_vendors/:companies_vendor_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies_vendors/:companies_vendor_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies_vendors/:companies_vendor_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies_vendors/:companies_vendor_id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies_vendors/:companies_vendor_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies_vendors/:companies_vendor_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies_vendors/:companies_vendor_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies_vendors/:companies_vendor_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies_vendors/:companies_vendor_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies_vendors/:companies_vendor_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies_vendors/:companies_vendor_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies_vendors/:companies_vendor_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies_vendors/:companies_vendor_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies_vendors/:companies_vendor_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies_vendors/:companies_vendor_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies_vendors/:companies_vendor_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies_vendors/:companies_vendor_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies_vendors/:companies_vendor_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies_vendors/:companies_vendor_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies_vendors/:companies_vendor_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies_vendors/:companies_vendor_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies_vendors/:companies_vendor_id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies_vendors/:companies_vendor_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies_vendors/:companies_vendor_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies_vendors/:companies_vendor_id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies_vendors/:companies_vendor_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies_vendors/:companies_vendor_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies_vendors/:companies_vendor_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies_vendors/:companies_vendor_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies_vendors/:companies_vendor_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies_vendors/:companies_vendor_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies_vendors/:companies_vendor_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies_vendors/:companies_vendor_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies_vendors/:companies_vendor_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies_vendors");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies_vendors" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies_vendors"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies_vendors"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies_vendors");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies_vendors"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies_vendors HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies_vendors")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies_vendors"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies_vendors")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies_vendors")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies_vendors');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies_vendors',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies_vendors';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies_vendors',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies_vendors")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies_vendors',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies_vendors',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies_vendors');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies_vendors',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies_vendors';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies_vendors"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies_vendors" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies_vendors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies_vendors', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies_vendors');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies_vendors');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies_vendors' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies_vendors' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies_vendors", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies_vendors"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies_vendors"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies_vendors")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies_vendors') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies_vendors";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies_vendors \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies_vendors

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies_vendors")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/companies_vendors/:companies_vendor_id/expense_statistics HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/companies_vendors/:companies_vendor_id/expense_statistics")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/companies_vendors/:companies_vendor_id/expense_statistics');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/companies_vendors/:companies_vendor_id/expense_statistics',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies_vendors/:companies_vendor_id/expense_statistics',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/companies_vendors/:companies_vendor_id/expense_statistics',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/companies_vendors/:companies_vendor_id/expense_statistics',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/companies_vendors/:companies_vendor_id/expense_statistics", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/companies_vendors/:companies_vendor_id/expense_statistics') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies_vendors/:companies_vendor_id/expense_statistics")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/company_settings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/company_settings" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/company_settings"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/company_settings"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/company_settings");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/company_settings"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/company_settings HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/company_settings")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/company_settings"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/company_settings")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/company_settings")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/company_settings');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/company_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/company_settings';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/company_settings',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/company_settings")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/company_settings',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/company_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/company_settings');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/company_settings',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/company_settings';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/company_settings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/company_settings" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/company_settings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/company_settings', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/company_settings');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/company_settings');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/company_settings' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/company_settings' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/company_settings", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/company_settings"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/company_settings"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/company_settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/company_settings') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/company_settings";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/company_settings \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/company_settings

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/company_settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/contact_custom_field_attributes/:contact_custom_field_attribute_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/contact_custom_field_attributes/:contact_custom_field_attribute_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/contact_custom_field_attributes/:contact_custom_field_attribute_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/contact_custom_field_attributes/:contact_custom_field_attribute_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contact_custom_field_attributes/:contact_custom_field_attribute_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/contact_custom_field_attributes/:contact_custom_field_attribute_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/contact_custom_field_attributes/:contact_custom_field_attribute_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/contact_custom_field_attributes/:contact_custom_field_attribute_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/contact_custom_field_attributes/:contact_custom_field_attribute_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact_custom_field_attributes/:contact_custom_field_attribute_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contact_custom_field_attributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/contact_custom_field_attributes" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/contact_custom_field_attributes"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/contact_custom_field_attributes"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contact_custom_field_attributes");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contact_custom_field_attributes"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/contact_custom_field_attributes HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contact_custom_field_attributes")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact_custom_field_attributes"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/contact_custom_field_attributes")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/contact_custom_field_attributes")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/contact_custom_field_attributes');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/contact_custom_field_attributes',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contact_custom_field_attributes';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/contact_custom_field_attributes',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contact_custom_field_attributes")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contact_custom_field_attributes',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/contact_custom_field_attributes',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contact_custom_field_attributes');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/contact_custom_field_attributes',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contact_custom_field_attributes';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contact_custom_field_attributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contact_custom_field_attributes" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contact_custom_field_attributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/contact_custom_field_attributes', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contact_custom_field_attributes');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contact_custom_field_attributes');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contact_custom_field_attributes' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact_custom_field_attributes' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/contact_custom_field_attributes", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contact_custom_field_attributes"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact_custom_field_attributes"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contact_custom_field_attributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/contact_custom_field_attributes') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contact_custom_field_attributes";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/contact_custom_field_attributes \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/contact_custom_field_attributes

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact_custom_field_attributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/contacts/:contact_id/contact_custom_field_values"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contacts/:contact_id/contact_custom_field_values");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/contacts/:contact_id/contact_custom_field_values HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:contact_id/contact_custom_field_values"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/contacts/:contact_id/contact_custom_field_values")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/contacts/:contact_id/contact_custom_field_values")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/contacts/:contact_id/contact_custom_field_values');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/contacts/:contact_id/contact_custom_field_values',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts/:contact_id/contact_custom_field_values';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/contacts/:contact_id/contact_custom_field_values',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:contact_id/contact_custom_field_values")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contacts/:contact_id/contact_custom_field_values',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/contacts/:contact_id/contact_custom_field_values',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contacts/:contact_id/contact_custom_field_values');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/contacts/:contact_id/contact_custom_field_values',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts/:contact_id/contact_custom_field_values';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:contact_id/contact_custom_field_values"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/contacts/:contact_id/contact_custom_field_values', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:contact_id/contact_custom_field_values');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contacts/:contact_id/contact_custom_field_values');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:contact_id/contact_custom_field_values' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:contact_id/contact_custom_field_values' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/contacts/:contact_id/contact_custom_field_values", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:contact_id/contact_custom_field_values")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/contacts/:contact_id/contact_custom_field_values') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/contacts/:contact_id/contact_custom_field_values \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/contacts/:contact_id/contact_custom_field_values

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts/:contact_id/contact_custom_field_values")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts/:contact_id/contact_persons");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
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  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/contacts/:contact_id/contact_persons" {:headers {:x-auth-token "{{apiKey}}"}
                                                                                 :content-type :json
                                                                                 :form-params {:email ""
                                                                                               :name ""
                                                                                               :phone ""
                                                                                               :title ""}})

require "http/client"

url = "{{baseUrl}}/contacts/:contact_id/contact_persons"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\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}}/contacts/:contact_id/contact_persons"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\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}}/contacts/:contact_id/contact_persons");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts/:contact_id/contact_persons"

	payload := strings.NewReader("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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/contacts/:contact_id/contact_persons HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contacts/:contact_id/contact_persons")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:contact_id/contact_persons"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\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  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contacts/:contact_id/contact_persons")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/contacts/:contact_id/contact_persons")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  email: '',
  name: '',
  phone: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/contacts/:contact_id/contact_persons');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contacts/:contact_id/contact_persons',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {email: '', name: '', phone: '', title: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"email":"","name":"","phone":"","title":""}'
};

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}}/contacts/:contact_id/contact_persons',
  method: 'POST',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "email": "",\n  "name": "",\n  "phone": "",\n  "title": ""\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  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:contact_id/contact_persons")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .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/contacts/:contact_id/contact_persons',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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: '', name: '', phone: '', title: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contacts/:contact_id/contact_persons',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {email: '', name: '', phone: '', title: ''},
  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}}/contacts/:contact_id/contact_persons');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  email: '',
  name: '',
  phone: '',
  title: ''
});

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}}/contacts/:contact_id/contact_persons',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {email: '', name: '', phone: '', title: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"email":"","name":"","phone":"","title":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"",
                              @"name": @"",
                              @"phone": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:contact_id/contact_persons"]
                                                       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}}/contacts/:contact_id/contact_persons" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts/:contact_id/contact_persons",
  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' => '',
    'name' => '',
    'phone' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/contacts/:contact_id/contact_persons', [
  'body' => '{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:contact_id/contact_persons');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'email' => '',
  'name' => '',
  'phone' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'email' => '',
  'name' => '',
  'phone' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/contacts/:contact_id/contact_persons');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/contacts/:contact_id/contact_persons", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts/:contact_id/contact_persons"

payload = {
    "email": "",
    "name": "",
    "phone": "",
    "title": ""
}
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:contact_id/contact_persons"

payload <- "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:contact_id/contact_persons")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\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/contacts/:contact_id/contact_persons') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contacts/:contact_id/contact_persons";

    let payload = json!({
        "email": "",
        "name": "",
        "phone": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}' |  \
  http POST {{baseUrl}}/contacts/:contact_id/contact_persons \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "email": "",\n  "name": "",\n  "phone": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/contacts/:contact_id/contact_persons

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts/:contact_id/contact_persons")! 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}}/contacts/:contact_id/contact_persons/:contact_person_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/contacts/:contact_id/contact_persons/:contact_person_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/contacts/:contact_id/contact_persons/:contact_person_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/contacts/:contact_id/contact_persons/:contact_person_id',
  method: 'DELETE',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/contacts/:contact_id/contact_persons/:contact_person_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"

response <- VERB("DELETE", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/contacts/:contact_id/contact_persons/:contact_person_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
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  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id" {:headers {:x-auth-token "{{apiKey}}"}
                                                                                                   :content-type :json
                                                                                                   :form-params {:email ""
                                                                                                                 :name ""
                                                                                                                 :phone ""
                                                                                                                 :title ""}})

require "http/client"

url = "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\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}}/contacts/:contact_id/contact_persons/:contact_person_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\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}}/contacts/:contact_id/contact_persons/:contact_person_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"

	payload := strings.NewReader("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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/contacts/:contact_id/contact_persons/:contact_person_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\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  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .put(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  email: '',
  name: '',
  phone: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {email: '', name: '', phone: '', title: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id';
const options = {
  method: 'PUT',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"email":"","name":"","phone":"","title":""}'
};

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}}/contacts/:contact_id/contact_persons/:contact_person_id',
  method: 'PUT',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "email": "",\n  "name": "",\n  "phone": "",\n  "title": ""\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  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .put(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .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/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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: '', name: '', phone: '', title: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {email: '', name: '', phone: '', title: ''},
  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}}/contacts/:contact_id/contact_persons/:contact_person_id');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  email: '',
  name: '',
  phone: '',
  title: ''
});

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}}/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {email: '', name: '', phone: '', title: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id';
const options = {
  method: 'PUT',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"email":"","name":"","phone":"","title":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"",
                              @"name": @"",
                              @"phone": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_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}}/contacts/:contact_id/contact_persons/:contact_person_id" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_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([
    'email' => '',
    'name' => '',
    'phone' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id', [
  'body' => '{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'email' => '',
  'name' => '',
  'phone' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'email' => '',
  'name' => '',
  'phone' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/contacts/:contact_id/contact_persons/:contact_person_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"

payload = {
    "email": "",
    "name": "",
    "phone": "",
    "title": ""
}
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"

payload <- "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\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/contacts/:contact_id/contact_persons/:contact_person_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"email\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"title\": \"\"\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}}/contacts/:contact_id/contact_persons/:contact_person_id";

    let payload = json!({
        "email": "",
        "name": "",
        "phone": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());
    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 '{
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
}' |  \
  http PUT {{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "email": "",\n  "name": "",\n  "phone": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "email": "",
  "name": "",
  "phone": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/contacts/:contact_id/contact_persons/:contact_person_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/contacts/:contact_id/contact_persons/:contact_person_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/contacts/:contact_id/contact_persons/:contact_person_id',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/contacts/:contact_id/contact_persons/:contact_person_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/contacts/:contact_id/contact_persons/:contact_person_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/contacts/:contact_id/contact_persons/:contact_person_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts/:contact_id/contact_persons/:contact_person_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts/:contact_id/contact_persons");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/contacts/:contact_id/contact_persons" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/contacts/:contact_id/contact_persons"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/contacts/:contact_id/contact_persons"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contacts/:contact_id/contact_persons");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts/:contact_id/contact_persons"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/contacts/:contact_id/contact_persons HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contacts/:contact_id/contact_persons")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:contact_id/contact_persons"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/contacts/:contact_id/contact_persons")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/contacts/:contact_id/contact_persons")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/contacts/:contact_id/contact_persons');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/contacts/:contact_id/contact_persons',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/contacts/:contact_id/contact_persons',
  method: 'GET',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:contact_id/contact_persons")
  .get()
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contacts/:contact_id/contact_persons',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/contacts/:contact_id/contact_persons',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contacts/:contact_id/contact_persons');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/contacts/:contact_id/contact_persons',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts/:contact_id/contact_persons';
const options = {method: 'GET', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:contact_id/contact_persons"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contacts/:contact_id/contact_persons" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts/:contact_id/contact_persons",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/contacts/:contact_id/contact_persons', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:contact_id/contact_persons');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contacts/:contact_id/contact_persons');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:contact_id/contact_persons' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("GET", "/baseUrl/contacts/:contact_id/contact_persons", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts/:contact_id/contact_persons"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:contact_id/contact_persons"

response <- VERB("GET", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:contact_id/contact_persons")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/contacts/:contact_id/contact_persons') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contacts/:contact_id/contact_persons";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/contacts/:contact_id/contact_persons \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/contacts/:contact_id/contact_persons

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts/:contact_id/contact_persons")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/contacts" {:headers {:x-auth-token "{{apiKey}}"}
                                                     :content-type :json
                                                     :form-params {:address ""
                                                                   :city_id ""
                                                                   :contact_types {:_ids []}
                                                                   :cvr ""
                                                                   :description ""
                                                                   :email ""
                                                                   :erp_id ""
                                                                   :name ""
                                                                   :phone ""
                                                                   :website ""}})

require "http/client"

url = "{{baseUrl}}/contacts"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\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}}/contacts"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\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}}/contacts");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts"

	payload := strings.NewReader("{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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/contacts HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 188

{
  "address": "",
  "city_id": "",
  "contact_types": {
    "_ids": []
  },
  "cvr": "",
  "description": "",
  "email": "",
  "erp_id": "",
  "name": "",
  "phone": "",
  "website": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contacts")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\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\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contacts")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/contacts")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  address: '',
  city_id: '',
  contact_types: {
    _ids: []
  },
  cvr: '',
  description: '',
  email: '',
  erp_id: '',
  name: '',
  phone: '',
  website: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/contacts');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contacts',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    address: '',
    city_id: '',
    contact_types: {_ids: []},
    cvr: '',
    description: '',
    email: '',
    erp_id: '',
    name: '',
    phone: '',
    website: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"address":"","city_id":"","contact_types":{"_ids":[]},"cvr":"","description":"","email":"","erp_id":"","name":"","phone":"","website":""}'
};

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}}/contacts',
  method: 'POST',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": "",\n  "city_id": "",\n  "contact_types": {\n    "_ids": []\n  },\n  "cvr": "",\n  "description": "",\n  "email": "",\n  "erp_id": "",\n  "name": "",\n  "phone": "",\n  "website": ""\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\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contacts")
  .post(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .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/contacts',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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: '',
  city_id: '',
  contact_types: {_ids: []},
  cvr: '',
  description: '',
  email: '',
  erp_id: '',
  name: '',
  phone: '',
  website: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contacts',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {
    address: '',
    city_id: '',
    contact_types: {_ids: []},
    cvr: '',
    description: '',
    email: '',
    erp_id: '',
    name: '',
    phone: '',
    website: ''
  },
  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}}/contacts');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  address: '',
  city_id: '',
  contact_types: {
    _ids: []
  },
  cvr: '',
  description: '',
  email: '',
  erp_id: '',
  name: '',
  phone: '',
  website: ''
});

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}}/contacts',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    address: '',
    city_id: '',
    contact_types: {_ids: []},
    cvr: '',
    description: '',
    email: '',
    erp_id: '',
    name: '',
    phone: '',
    website: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts';
const options = {
  method: 'POST',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"address":"","city_id":"","contact_types":{"_ids":[]},"cvr":"","description":"","email":"","erp_id":"","name":"","phone":"","website":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"address": @"",
                              @"city_id": @"",
                              @"contact_types": @{ @"_ids": @[  ] },
                              @"cvr": @"",
                              @"description": @"",
                              @"email": @"",
                              @"erp_id": @"",
                              @"name": @"",
                              @"phone": @"",
                              @"website": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts"]
                                                       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}}/contacts" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts",
  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([
    'address' => '',
    'city_id' => '',
    'contact_types' => [
        '_ids' => [
                
        ]
    ],
    'cvr' => '',
    'description' => '',
    'email' => '',
    'erp_id' => '',
    'name' => '',
    'phone' => '',
    'website' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/contacts', [
  'body' => '{
  "address": "",
  "city_id": "",
  "contact_types": {
    "_ids": []
  },
  "cvr": "",
  "description": "",
  "email": "",
  "erp_id": "",
  "name": "",
  "phone": "",
  "website": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => '',
  'city_id' => '',
  'contact_types' => [
    '_ids' => [
        
    ]
  ],
  'cvr' => '',
  'description' => '',
  'email' => '',
  'erp_id' => '',
  'name' => '',
  'phone' => '',
  'website' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'address' => '',
  'city_id' => '',
  'contact_types' => [
    '_ids' => [
        
    ]
  ],
  'cvr' => '',
  'description' => '',
  'email' => '',
  'erp_id' => '',
  'name' => '',
  'phone' => '',
  'website' => ''
]));
$request->setRequestUrl('{{baseUrl}}/contacts');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": "",
  "city_id": "",
  "contact_types": {
    "_ids": []
  },
  "cvr": "",
  "description": "",
  "email": "",
  "erp_id": "",
  "name": "",
  "phone": "",
  "website": ""
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": "",
  "city_id": "",
  "contact_types": {
    "_ids": []
  },
  "cvr": "",
  "description": "",
  "email": "",
  "erp_id": "",
  "name": "",
  "phone": "",
  "website": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/contacts", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts"

payload = {
    "address": "",
    "city_id": "",
    "contact_types": { "_ids": [] },
    "cvr": "",
    "description": "",
    "email": "",
    "erp_id": "",
    "name": "",
    "phone": "",
    "website": ""
}
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts"

payload <- "{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\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/contacts') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"address\": \"\",\n  \"city_id\": \"\",\n  \"contact_types\": {\n    \"_ids\": []\n  },\n  \"cvr\": \"\",\n  \"description\": \"\",\n  \"email\": \"\",\n  \"erp_id\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"website\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contacts";

    let payload = json!({
        "address": "",
        "city_id": "",
        "contact_types": json!({"_ids": ()}),
        "cvr": "",
        "description": "",
        "email": "",
        "erp_id": "",
        "name": "",
        "phone": "",
        "website": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "address": "",
  "city_id": "",
  "contact_types": {
    "_ids": []
  },
  "cvr": "",
  "description": "",
  "email": "",
  "erp_id": "",
  "name": "",
  "phone": "",
  "website": ""
}' |  \
  http POST {{baseUrl}}/contacts \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": "",\n  "city_id": "",\n  "contact_types": {\n    "_ids": []\n  },\n  "cvr": "",\n  "description": "",\n  "email": "",\n  "erp_id": "",\n  "name": "",\n  "phone": "",\n  "website": ""\n}' \
  --output-document \
  - {{baseUrl}}/contacts

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "address": "",
  "city_id": "",
  "contact_types": ["_ids": []],
  "cvr": "",
  "description": "",
  "email": "",
  "erp_id": "",
  "name": "",
  "phone": "",
  "website": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts")! 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}}/contacts/bulkDelete");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"id\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/contacts/bulkDelete" {:headers {:x-auth-token "{{apiKey}}"}
                                                                  :content-type :json
                                                                  :form-params {:id []}})

require "http/client"

url = "{{baseUrl}}/contacts/bulkDelete"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": []\n}"

response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/contacts/bulkDelete"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"id\": []\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}}/contacts/bulkDelete");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts/bulkDelete"

	payload := strings.NewReader("{\n  \"id\": []\n}")

	req, _ := http.NewRequest("DELETE", url, payload)

	req.Header.Add("x-auth-token", "{{apiKey}}")
	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))

}

DELETE /baseUrl/contacts/bulkDelete HTTP/1.1
X-Auth-Token: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 14

{
  "id": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contacts/bulkDelete")
  .setHeader("x-auth-token", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/bulkDelete"))
    .header("x-auth-token", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("{\n  \"id\": []\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  \"id\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contacts/bulkDelete")
  .delete(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/contacts/bulkDelete")
  .header("x-auth-token", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"id\": []\n}")
  .asString();

const data = JSON.stringify({
  id: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/contacts/bulkDelete');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/contacts/bulkDelete',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {id: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts/bulkDelete';
const options = {
  method: 'DELETE',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"id":[]}'
};

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}}/contacts/bulkDelete',
  method: 'DELETE',
  headers: {
    'x-auth-token': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contacts/bulkDelete")
  .delete(body)
  .addHeader("x-auth-token", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contacts/bulkDelete',
  headers: {
    'x-auth-token': '{{apiKey}}',
    '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({id: []}));
req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/contacts/bulkDelete',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: {id: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/contacts/bulkDelete');

req.headers({
  'x-auth-token': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  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}}/contacts/bulkDelete',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  data: {id: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts/bulkDelete';
const options = {
  method: 'DELETE',
  headers: {'x-auth-token': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"id":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"id": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/bulkDelete"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/contacts/bulkDelete" in
let headers = Header.add_list (Header.init ()) [
  ("x-auth-token", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": []\n}" in

Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts/bulkDelete",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/contacts/bulkDelete', [
  'body' => '{
  "id": []
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/bulkDelete');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/contacts/bulkDelete');
$request->setRequestMethod('DELETE');
$request->setBody($body);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/bulkDelete' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "id": []
}'

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/bulkDelete' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "id": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": []\n}"

headers = {
    'x-auth-token': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("DELETE", "/baseUrl/contacts/bulkDelete", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts/bulkDelete"

payload = { "id": [] }
headers = {
    "x-auth-token": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.delete(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/bulkDelete"

payload <- "{\n  \"id\": []\n}"

encode <- "json"

response <- VERB("DELETE", url, body = payload, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/bulkDelete")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": []\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.delete('/baseUrl/contacts/bulkDelete') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
  req.body = "{\n  \"id\": []\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}}/contacts/bulkDelete";

    let payload = json!({"id": ()});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "id": []
}' |  \
  http DELETE {{baseUrl}}/contacts/bulkDelete \
  content-type:application/json \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-auth-token: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": []\n}' \
  --output-document \
  - {{baseUrl}}/contacts/bulkDelete

import Foundation

let headers = [
  "x-auth-token": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["id": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts/bulkDelete")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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}}/contacts/:contact_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/contacts/:contact_id" {:headers {:x-auth-token "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/contacts/:contact_id"
headers = HTTP::Headers{
  "x-auth-token" => "{{apiKey}}"
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/contacts/:contact_id"),
    Headers =
    {
        { "x-auth-token", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contacts/:contact_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts/:contact_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("x-auth-token", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/contacts/:contact_id HTTP/1.1
X-Auth-Token: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contacts/:contact_id")
  .setHeader("x-auth-token", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:contact_id"))
    .header("x-auth-token", "{{apiKey}}")
    .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}}/contacts/:contact_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/contacts/:contact_id")
  .header("x-auth-token", "{{apiKey}}")
  .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}}/contacts/:contact_id');
xhr.setRequestHeader('x-auth-token', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/contacts/:contact_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts/:contact_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

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}}/contacts/:contact_id',
  method: 'DELETE',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:contact_id")
  .delete(null)
  .addHeader("x-auth-token", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contacts/:contact_id',
  headers: {
    'x-auth-token': '{{apiKey}}'
  }
};

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}}/contacts/:contact_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/contacts/:contact_id');

req.headers({
  'x-auth-token': '{{apiKey}}'
});

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}}/contacts/:contact_id',
  headers: {'x-auth-token': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts/:contact_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-auth-token": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:contact_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contacts/:contact_id" in
let headers = Header.add (Header.init ()) "x-auth-token" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts/:contact_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-auth-token: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/contacts/:contact_id', [
  'headers' => [
    'x-auth-token' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:contact_id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contacts/:contact_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'x-auth-token' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:contact_id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-auth-token", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:contact_id' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-auth-token': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/contacts/:contact_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts/:contact_id"

headers = {"x-auth-token": "{{apiKey}}"}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:contact_id"

response <- VERB("DELETE", url, add_headers('x-auth-token' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:contact_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/contacts/:contact_id') do |req|
  req.headers['x-auth-token'] = '{{apiKey}}'
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contacts/:contact_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-auth-token", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/contacts/:contact_id \
  x-auth-token:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-auth-token: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/contacts/:contact_id

import Foundation

let headers = ["x-auth-token": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts/:contact_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()