XTRF Home Portal APIv2.0

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/for/:className");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/browser/views/for/:className")

require "http/client"

url = "{{baseUrl}}/browser/views/for/:className"

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

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

var client = new RestClient("{{baseUrl}}/browser/views/for/:className");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/for/:className"

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

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

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

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

}

POST /baseUrl/browser/views/for/:className HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/browser/views/for/:className")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/browser/views/for/:className")
  .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}}/browser/views/for/:className');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/browser/views/for/:className'
};

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

const url = '{{baseUrl}}/browser/views/for/:className';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/browser/views/for/:className',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/for/:className")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/browser/views/for/:className',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/browser/views/for/:className'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/browser/views/for/:className');

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}}/browser/views/for/:className'
};

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

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

const url = '{{baseUrl}}/browser/views/for/:className';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/browser/views/for/:className"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/browser/views/for/:className" in

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

 "{{baseUrl}}/browser/views/for/:className",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/browser/views/for/:className');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/for/:className');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/browser/views/for/:className');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/for/:className' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/for/:className' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/browser/views/for/:className")

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

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

import requests

url = "{{baseUrl}}/browser/views/for/:className"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/for/:className"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/for/:className")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/browser/views/for/:className') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/browser/views/for/:className

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/browser/views/for/:className

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/for/:className")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId/columns/:columnName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/browser/views/:viewId/columns/:columnName")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/columns/:columnName"

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/columns/:columnName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/columns/:columnName"

	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/browser/views/:viewId/columns/:columnName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/browser/views/:viewId/columns/:columnName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/browser/views/:viewId/columns/:columnName")
  .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}}/browser/views/:viewId/columns/:columnName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/browser/views/:viewId/columns/:columnName'
};

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

const url = '{{baseUrl}}/browser/views/:viewId/columns/:columnName';
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}}/browser/views/:viewId/columns/:columnName',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/columns/:columnName")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/browser/views/:viewId/columns/:columnName');

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}}/browser/views/:viewId/columns/:columnName'
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/columns/:columnName';
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}}/browser/views/:viewId/columns/:columnName"]
                                                       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}}/browser/views/:viewId/columns/:columnName" in

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

 "{{baseUrl}}/browser/views/:viewId/columns/:columnName",
  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}}/browser/views/:viewId/columns/:columnName');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/columns/:columnName');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/columns/:columnName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/columns/:columnName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/columns/:columnName' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/browser/views/:viewId/columns/:columnName")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/columns/:columnName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/columns/:columnName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/columns/:columnName")

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/browser/views/:viewId/columns/:columnName') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/browser/views/:viewId/columns/:columnName";

    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}}/browser/views/:viewId/columns/:columnName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/columns/:columnName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/columns/:columnName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/browser/views/:viewId")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/browser/views/:viewId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/browser/views/:viewId');

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}}/browser/views/:viewId'};

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

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

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

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

 "{{baseUrl}}/browser/views/:viewId",
  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}}/browser/views/:viewId');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/browser/views/:viewId")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId")

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/browser/views/:viewId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/browser/views/:viewId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/:viewId")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/browser/views/:viewId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/:viewId');

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}}/browser/views/:viewId'};

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

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

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

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

 "{{baseUrl}}/browser/views/:viewId",
  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}}/browser/views/:viewId');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/:viewId")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId")

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/browser/views/:viewId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/:viewId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId")! 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}}/browser/views/:viewId/columns/:columnName/settings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"

	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/browser/views/:viewId/columns/:columnName/settings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"))
    .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}}/browser/views/:viewId/columns/:columnName/settings")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")
  .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}}/browser/views/:viewId/columns/:columnName/settings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings'
};

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

const url = '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings';
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}}/browser/views/:viewId/columns/:columnName/settings',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings');

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}}/browser/views/:viewId/columns/:columnName/settings'
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings';
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}}/browser/views/:viewId/columns/:columnName/settings"]
                                                       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}}/browser/views/:viewId/columns/:columnName/settings" in

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

 "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings",
  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}}/browser/views/:viewId/columns/:columnName/settings');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/:viewId/columns/:columnName/settings")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")

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/browser/views/:viewId/columns/:columnName/settings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/:viewId/columns/:columnName/settings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/columns/:columnName/settings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")! 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}}/browser/views/:viewId/columns");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/:viewId/columns")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/columns"

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/columns");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/columns"

	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/browser/views/:viewId/columns HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/browser/views/:viewId/columns'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/columns")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/:viewId/columns');

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}}/browser/views/:viewId/columns'
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/columns';
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}}/browser/views/:viewId/columns"]
                                                       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}}/browser/views/:viewId/columns" in

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

 "{{baseUrl}}/browser/views/:viewId/columns",
  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}}/browser/views/:viewId/columns');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/columns');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/columns');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/columns' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/columns' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/:viewId/columns")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/columns"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/columns"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/columns")

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/browser/views/:viewId/columns') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/:viewId/columns

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/columns

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/columns")! 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}}/browser/views/details/for/:className");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/details/for/:className")

require "http/client"

url = "{{baseUrl}}/browser/views/details/for/:className"

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

var client = new RestClient("{{baseUrl}}/browser/views/details/for/:className");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/details/for/:className"

	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/browser/views/details/for/:className HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/details/for/:className"))
    .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}}/browser/views/details/for/:className")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/browser/views/details/for/:className")
  .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}}/browser/views/details/for/:className');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/browser/views/details/for/:className'
};

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

const url = '{{baseUrl}}/browser/views/details/for/:className';
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}}/browser/views/details/for/:className',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/details/for/:className")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/details/for/:className');

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}}/browser/views/details/for/:className'
};

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

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

const url = '{{baseUrl}}/browser/views/details/for/:className';
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}}/browser/views/details/for/:className"]
                                                       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}}/browser/views/details/for/:className" in

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

 "{{baseUrl}}/browser/views/details/for/:className",
  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}}/browser/views/details/for/:className');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/details/for/:className');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/details/for/:className');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/details/for/:className' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/details/for/:className' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/details/for/:className")

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

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

import requests

url = "{{baseUrl}}/browser/views/details/for/:className"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/details/for/:className"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/details/for/:className")

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/browser/views/details/for/:className') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/browser/views/details/for/:className";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/details/for/:className

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/details/for/:className

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/details/for/:className")! 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}}/browser/views/details/for/:className/:viewId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/details/for/:className/:viewId")

require "http/client"

url = "{{baseUrl}}/browser/views/details/for/:className/:viewId"

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

var client = new RestClient("{{baseUrl}}/browser/views/details/for/:className/:viewId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/details/for/:className/:viewId"

	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/browser/views/details/for/:className/:viewId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/browser/views/details/for/:className/:viewId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/details/for/:className/:viewId"))
    .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}}/browser/views/details/for/:className/:viewId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/browser/views/details/for/:className/:viewId")
  .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}}/browser/views/details/for/:className/:viewId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/browser/views/details/for/:className/:viewId'
};

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

const url = '{{baseUrl}}/browser/views/details/for/:className/:viewId';
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}}/browser/views/details/for/:className/:viewId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/details/for/:className/:viewId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/details/for/:className/:viewId');

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}}/browser/views/details/for/:className/:viewId'
};

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

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

const url = '{{baseUrl}}/browser/views/details/for/:className/:viewId';
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}}/browser/views/details/for/:className/:viewId"]
                                                       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}}/browser/views/details/for/:className/:viewId" in

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

 "{{baseUrl}}/browser/views/details/for/:className/:viewId",
  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}}/browser/views/details/for/:className/:viewId');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/details/for/:className/:viewId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/details/for/:className/:viewId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/details/for/:className/:viewId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/details/for/:className/:viewId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/details/for/:className/:viewId")

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

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

import requests

url = "{{baseUrl}}/browser/views/details/for/:className/:viewId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/details/for/:className/:viewId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/details/for/:className/:viewId")

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/browser/views/details/for/:className/:viewId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/browser/views/details/for/:className/:viewId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/details/for/:className/:viewId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/details/for/:className/:viewId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/details/for/:className/:viewId")! 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}}/browser/views/:viewId/filter");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/:viewId/filter")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/filter"

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/filter");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/filter"

	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/browser/views/:viewId/filter HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/browser/views/:viewId/filter'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/filter")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/:viewId/filter');

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}}/browser/views/:viewId/filter'};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/filter';
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}}/browser/views/:viewId/filter"]
                                                       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}}/browser/views/:viewId/filter" in

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

 "{{baseUrl}}/browser/views/:viewId/filter",
  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}}/browser/views/:viewId/filter');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/filter');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/filter');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/filter' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/filter' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/:viewId/filter")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/filter"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/filter"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/filter")

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/browser/views/:viewId/filter') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/:viewId/filter

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/filter

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/filter")! 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}}/browser/views/:viewId/settings/local");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/:viewId/settings/local")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/settings/local"

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/settings/local");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/settings/local"

	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/browser/views/:viewId/settings/local HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/:viewId/settings/local"))
    .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}}/browser/views/:viewId/settings/local")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/browser/views/:viewId/settings/local")
  .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}}/browser/views/:viewId/settings/local');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/browser/views/:viewId/settings/local'
};

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

const url = '{{baseUrl}}/browser/views/:viewId/settings/local';
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}}/browser/views/:viewId/settings/local',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/settings/local")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/:viewId/settings/local');

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}}/browser/views/:viewId/settings/local'
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/settings/local';
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}}/browser/views/:viewId/settings/local"]
                                                       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}}/browser/views/:viewId/settings/local" in

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

 "{{baseUrl}}/browser/views/:viewId/settings/local",
  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}}/browser/views/:viewId/settings/local');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/settings/local');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/settings/local');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/settings/local' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/settings/local' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/:viewId/settings/local")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/settings/local"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/settings/local"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/settings/local")

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/browser/views/:viewId/settings/local') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/browser/views/:viewId/settings/local";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/:viewId/settings/local

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/settings/local

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/settings/local")! 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}}/browser/views/:viewId/order");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/:viewId/order")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/order"

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/order");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/order"

	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/browser/views/:viewId/order HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/browser/views/:viewId/order'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/order")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/:viewId/order');

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}}/browser/views/:viewId/order'};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/order';
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}}/browser/views/:viewId/order"]
                                                       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}}/browser/views/:viewId/order" in

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

 "{{baseUrl}}/browser/views/:viewId/order",
  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}}/browser/views/:viewId/order');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/order');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/order');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/order' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/order' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/:viewId/order")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/order"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/order"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/order")

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/browser/views/:viewId/order') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/:viewId/order

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/order

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/order")! 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}}/browser/views/:viewId/permissions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/:viewId/permissions")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/permissions"

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/permissions"

	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/browser/views/:viewId/permissions HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/browser/views/:viewId/permissions'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/permissions")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/:viewId/permissions');

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}}/browser/views/:viewId/permissions'
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/permissions';
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}}/browser/views/:viewId/permissions"]
                                                       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}}/browser/views/:viewId/permissions" in

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

 "{{baseUrl}}/browser/views/:viewId/permissions",
  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}}/browser/views/:viewId/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/permissions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/permissions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/permissions' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/:viewId/permissions")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/permissions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/permissions")

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/browser/views/:viewId/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/:viewId/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/permissions")! 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}}/browser/views/:viewId/settings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/:viewId/settings")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/settings"

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/settings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/settings"

	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/browser/views/:viewId/settings HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/browser/views/:viewId/settings'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/settings")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/:viewId/settings');

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}}/browser/views/:viewId/settings'
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/settings';
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}}/browser/views/:viewId/settings"]
                                                       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}}/browser/views/:viewId/settings" in

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

 "{{baseUrl}}/browser/views/:viewId/settings",
  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}}/browser/views/:viewId/settings');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/settings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/settings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/settings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/settings' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/:viewId/settings")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/settings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/settings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/settings")

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/browser/views/:viewId/settings') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/:viewId/settings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/settings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/settings")! 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}}/browser/views/for/:className");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/views/for/:className")

require "http/client"

url = "{{baseUrl}}/browser/views/for/:className"

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

var client = new RestClient("{{baseUrl}}/browser/views/for/:className");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/for/:className"

	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/browser/views/for/:className HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/browser/views/for/:className'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/for/:className")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/browser/views/for/:className');

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}}/browser/views/for/:className'};

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

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

const url = '{{baseUrl}}/browser/views/for/:className';
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}}/browser/views/for/:className"]
                                                       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}}/browser/views/for/:className" in

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

 "{{baseUrl}}/browser/views/for/:className",
  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}}/browser/views/for/:className');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/for/:className');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/browser/views/for/:className');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/for/:className' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/for/:className' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/browser/views/for/:className")

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

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

import requests

url = "{{baseUrl}}/browser/views/for/:className"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/for/:className"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/for/:className")

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/browser/views/for/:className') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/views/for/:className

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/browser/views/for/:className

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/for/:className")! 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}}/browser/csv");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/browser/csv")

require "http/client"

url = "{{baseUrl}}/browser/csv"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/browser/csv"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/browser/csv")

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

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

import requests

url = "{{baseUrl}}/browser/csv"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/csv"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/csv")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser/csv

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/browser"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/browser"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/browser

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/details/for/:className/:viewId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/browser/views/details/for/:className/:viewId")

require "http/client"

url = "{{baseUrl}}/browser/views/details/for/:className/:viewId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/browser/views/details/for/:className/:viewId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/browser/views/details/for/:className/:viewId");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/details/for/:className/:viewId"

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

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

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

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

}

POST /baseUrl/browser/views/details/for/:className/:viewId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/browser/views/details/for/:className/:viewId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/details/for/:className/:viewId"))
    .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}}/browser/views/details/for/:className/:viewId")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/browser/views/details/for/:className/:viewId")
  .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}}/browser/views/details/for/:className/:viewId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/browser/views/details/for/:className/:viewId'
};

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

const url = '{{baseUrl}}/browser/views/details/for/:className/:viewId';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/browser/views/details/for/:className/:viewId',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/details/for/:className/:viewId")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/browser/views/details/for/:className/:viewId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/browser/views/details/for/:className/:viewId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/browser/views/details/for/:className/:viewId');

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}}/browser/views/details/for/:className/:viewId'
};

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

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

const url = '{{baseUrl}}/browser/views/details/for/:className/:viewId';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/browser/views/details/for/:className/:viewId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/browser/views/details/for/:className/:viewId" in

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

 "{{baseUrl}}/browser/views/details/for/:className/:viewId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/browser/views/details/for/:className/:viewId');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/details/for/:className/:viewId');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/browser/views/details/for/:className/:viewId');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/details/for/:className/:viewId' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/details/for/:className/:viewId' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/browser/views/details/for/:className/:viewId")

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

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

import requests

url = "{{baseUrl}}/browser/views/details/for/:className/:viewId"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/details/for/:className/:viewId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/details/for/:className/:viewId")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/browser/views/details/for/:className/:viewId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/browser/views/details/for/:className/:viewId";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/browser/views/details/for/:className/:viewId

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/browser/views/details/for/:className/:viewId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/details/for/:className/:viewId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/browser/views/:viewId")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId"

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

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId"

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

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

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

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

}

PUT /baseUrl/browser/views/:viewId HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/:viewId"))
    .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}}/browser/views/:viewId")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/browser/views/:viewId")
  .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}}/browser/views/:viewId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/browser/views/:viewId'};

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

const url = '{{baseUrl}}/browser/views/:viewId';
const options = {method: 'PUT'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/browser/views/:viewId',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/browser/views/:viewId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/browser/views/:viewId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/browser/views/:viewId');

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}}/browser/views/:viewId'};

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

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

const url = '{{baseUrl}}/browser/views/:viewId';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/browser/views/:viewId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/browser/views/:viewId" in

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

 "{{baseUrl}}/browser/views/:viewId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/browser/views/:viewId');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId' -Method PUT 

import http.client

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

conn.request("PUT", "/baseUrl/browser/views/:viewId")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId")

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

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

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

require 'faraday'

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

response = conn.put('/baseUrl/browser/views/:viewId') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/browser/views/:viewId

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/browser/views/:viewId/columns/:columnName/settings"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"

	payload := strings.NewReader("{}")

	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/browser/views/:viewId/columns/:columnName/settings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('PUT', '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings';
const options = {method: 'PUT', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")
  .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/browser/views/:viewId/columns/:columnName/settings',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings');

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

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

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings';
const options = {method: 'PUT', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"]
                                                       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}}/browser/views/:viewId/columns/:columnName/settings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings",
  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([
    
  ]),
  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}}/browser/views/:viewId/columns/:columnName/settings', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings');
$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}}/browser/views/:viewId/columns/:columnName/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("PUT", "/baseUrl/browser/views/:viewId/columns/:columnName/settings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings"

payload <- "{}"

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}}/browser/views/:viewId/columns/:columnName/settings")

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 = "{}"

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/browser/views/:viewId/columns/:columnName/settings') do |req|
  req.body = "{}"
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}}/browser/views/:viewId/columns/:columnName/settings";

    let payload = json!({});

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

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

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

    dbg!(results);
}

echo '{}' |  \
  http PUT {{baseUrl}}/browser/views/:viewId/columns/:columnName/settings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/columns/:columnName/settings

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/columns/:columnName/settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId/columns");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/browser/views/:viewId/columns")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/columns"

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

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/columns");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/columns"

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

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

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

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

}

PUT /baseUrl/browser/views/:viewId/columns HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/browser/views/:viewId/columns")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/:viewId/columns"))
    .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}}/browser/views/:viewId/columns")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/browser/views/:viewId/columns")
  .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}}/browser/views/:viewId/columns');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/columns'
};

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

const url = '{{baseUrl}}/browser/views/:viewId/columns';
const options = {method: 'PUT'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/browser/views/:viewId/columns',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/columns")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/browser/views/:viewId/columns',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/columns'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/browser/views/:viewId/columns');

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}}/browser/views/:viewId/columns'
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/columns';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/browser/views/:viewId/columns"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/browser/views/:viewId/columns" in

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

 "{{baseUrl}}/browser/views/:viewId/columns",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/browser/views/:viewId/columns');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/columns');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/columns');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/columns' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/columns' -Method PUT 

import http.client

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

conn.request("PUT", "/baseUrl/browser/views/:viewId/columns")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/columns"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/columns"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/columns")

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

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

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

require 'faraday'

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

response = conn.put('/baseUrl/browser/views/:viewId/columns') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/browser/views/:viewId/columns

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/columns

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/columns")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId/filter/:filterProperty");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/browser/views/:viewId/filter/:filterProperty" {:content-type :json
                                                                                        :form-params {:name ""
                                                                                                      :settings {}
                                                                                                      :settingsPresent false
                                                                                                      :type ""}})

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/filter/:filterProperty"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\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}}/browser/views/:viewId/filter/:filterProperty"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/filter/:filterProperty");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/filter/:filterProperty"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\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/browser/views/:viewId/filter/:filterProperty HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "name": "",
  "settings": {},
  "settingsPresent": false,
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/browser/views/:viewId/filter/:filterProperty")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/:viewId/filter/:filterProperty"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/filter/:filterProperty")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/browser/views/:viewId/filter/:filterProperty")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  settings: {},
  settingsPresent: false,
  type: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty',
  headers: {'content-type': 'application/json'},
  data: {name: '', settings: {}, settingsPresent: false, type: ''}
};

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

const url = '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","settings":{},"settingsPresent":false,"type":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "settings": {},\n  "settingsPresent": false,\n  "type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/filter/:filterProperty")
  .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/browser/views/:viewId/filter/:filterProperty',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({name: '', settings: {}, settingsPresent: false, type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty',
  headers: {'content-type': 'application/json'},
  body: {name: '', settings: {}, settingsPresent: false, type: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty');

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

req.type('json');
req.send({
  name: '',
  settings: {},
  settingsPresent: false,
  type: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty',
  headers: {'content-type': 'application/json'},
  data: {name: '', settings: {}, settingsPresent: false, type: ''}
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","settings":{},"settingsPresent":false,"type":""}'
};

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

#import 

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

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

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

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

 "{{baseUrl}}/browser/views/:viewId/filter/:filterProperty",
  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([
    'name' => '',
    'settings' => [
        
    ],
    'settingsPresent' => null,
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty', [
  'body' => '{
  "name": "",
  "settings": {},
  "settingsPresent": false,
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/filter/:filterProperty');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'settings' => [
    
  ],
  'settingsPresent' => null,
  'type' => ''
]));

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

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

append(json_encode([
  'name' => '',
  'settings' => [
    
  ],
  'settingsPresent' => null,
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/browser/views/:viewId/filter/:filterProperty');
$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}}/browser/views/:viewId/filter/:filterProperty' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "settings": {},
  "settingsPresent": false,
  "type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/filter/:filterProperty' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "settings": {},
  "settingsPresent": false,
  "type": ""
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/browser/views/:viewId/filter/:filterProperty", payload, headers)

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/filter/:filterProperty"

payload = {
    "name": "",
    "settings": {},
    "settingsPresent": False,
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/filter/:filterProperty"

payload <- "{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\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}}/browser/views/:viewId/filter/:filterProperty")

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  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/browser/views/:viewId/filter/:filterProperty') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"settings\": {},\n  \"settingsPresent\": false,\n  \"type\": \"\"\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}}/browser/views/:viewId/filter/:filterProperty";

    let payload = json!({
        "name": "",
        "settings": json!({}),
        "settingsPresent": false,
        "type": ""
    });

    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 '{
  "name": "",
  "settings": {},
  "settingsPresent": false,
  "type": ""
}' |  \
  http PUT {{baseUrl}}/browser/views/:viewId/filter/:filterProperty \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "settings": {},\n  "settingsPresent": false,\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/filter/:filterProperty

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/filter/:filterProperty")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId/filter");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/browser/views/:viewId/filter")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/filter"

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

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/filter");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/filter"

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

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

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

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

}

PUT /baseUrl/browser/views/:viewId/filter HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/browser/views/:viewId/filter")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/:viewId/filter"))
    .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}}/browser/views/:viewId/filter")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/browser/views/:viewId/filter")
  .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}}/browser/views/:viewId/filter');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/browser/views/:viewId/filter'};

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

const url = '{{baseUrl}}/browser/views/:viewId/filter';
const options = {method: 'PUT'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/browser/views/:viewId/filter',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/filter")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/browser/views/:viewId/filter',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/browser/views/:viewId/filter'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/browser/views/:viewId/filter');

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}}/browser/views/:viewId/filter'};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/filter';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/browser/views/:viewId/filter"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/browser/views/:viewId/filter" in

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

 "{{baseUrl}}/browser/views/:viewId/filter",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/browser/views/:viewId/filter');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/filter');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/filter');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/filter' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/filter' -Method PUT 

import http.client

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

conn.request("PUT", "/baseUrl/browser/views/:viewId/filter")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/filter"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/filter"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/filter")

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

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

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

require 'faraday'

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

response = conn.put('/baseUrl/browser/views/:viewId/filter') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/browser/views/:viewId/filter

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/filter

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/filter")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId/settings/local");

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  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/browser/views/:viewId/settings/local" {:content-type :json
                                                                                :form-params {:maxLinesInRow 0
                                                                                              :maxRows 0}})

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/settings/local"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\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}}/browser/views/:viewId/settings/local"),
    Content = new StringContent("{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/settings/local");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/settings/local"

	payload := strings.NewReader("{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\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/browser/views/:viewId/settings/local HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "maxLinesInRow": 0,
  "maxRows": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/browser/views/:viewId/settings/local")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/:viewId/settings/local"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/settings/local")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/browser/views/:viewId/settings/local")
  .header("content-type", "application/json")
  .body("{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}")
  .asString();

const data = JSON.stringify({
  maxLinesInRow: 0,
  maxRows: 0
});

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

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

xhr.open('PUT', '{{baseUrl}}/browser/views/:viewId/settings/local');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/settings/local',
  headers: {'content-type': 'application/json'},
  data: {maxLinesInRow: 0, maxRows: 0}
};

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

const url = '{{baseUrl}}/browser/views/:viewId/settings/local';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"maxLinesInRow":0,"maxRows":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/browser/views/:viewId/settings/local',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "maxLinesInRow": 0,\n  "maxRows": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/settings/local")
  .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/browser/views/:viewId/settings/local',
  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({maxLinesInRow: 0, maxRows: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/settings/local',
  headers: {'content-type': 'application/json'},
  body: {maxLinesInRow: 0, maxRows: 0},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/browser/views/:viewId/settings/local');

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

req.type('json');
req.send({
  maxLinesInRow: 0,
  maxRows: 0
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/settings/local',
  headers: {'content-type': 'application/json'},
  data: {maxLinesInRow: 0, maxRows: 0}
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/settings/local';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"maxLinesInRow":0,"maxRows":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"maxLinesInRow": @0,
                              @"maxRows": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/browser/views/:viewId/settings/local"]
                                                       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}}/browser/views/:viewId/settings/local" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}" in

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

 "{{baseUrl}}/browser/views/:viewId/settings/local",
  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([
    'maxLinesInRow' => 0,
    'maxRows' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/browser/views/:viewId/settings/local', [
  'body' => '{
  "maxLinesInRow": 0,
  "maxRows": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/settings/local');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'maxLinesInRow' => 0,
  'maxRows' => 0
]));

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

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

append(json_encode([
  'maxLinesInRow' => 0,
  'maxRows' => 0
]));
$request->setRequestUrl('{{baseUrl}}/browser/views/:viewId/settings/local');
$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}}/browser/views/:viewId/settings/local' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "maxLinesInRow": 0,
  "maxRows": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/settings/local' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "maxLinesInRow": 0,
  "maxRows": 0
}'

import http.client

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

payload = "{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}"

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

conn.request("PUT", "/baseUrl/browser/views/:viewId/settings/local", payload, headers)

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/settings/local"

payload = {
    "maxLinesInRow": 0,
    "maxRows": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/settings/local"

payload <- "{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\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}}/browser/views/:viewId/settings/local")

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  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/browser/views/:viewId/settings/local') do |req|
  req.body = "{\n  \"maxLinesInRow\": 0,\n  \"maxRows\": 0\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}}/browser/views/:viewId/settings/local";

    let payload = json!({
        "maxLinesInRow": 0,
        "maxRows": 0
    });

    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 '{
  "maxLinesInRow": 0,
  "maxRows": 0
}' |  \
  http PUT {{baseUrl}}/browser/views/:viewId/settings/local \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "maxLinesInRow": 0,\n  "maxRows": 0\n}' \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/settings/local

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "maxLinesInRow": 0,
  "maxRows": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/settings/local")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId/order");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/browser/views/:viewId/order")

require "http/client"

url = "{{baseUrl}}/browser/views/:viewId/order"

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

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

var client = new RestClient("{{baseUrl}}/browser/views/:viewId/order");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/order"

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

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

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

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

}

PUT /baseUrl/browser/views/:viewId/order HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/browser/views/:viewId/order")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/browser/views/:viewId/order"))
    .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}}/browser/views/:viewId/order")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/browser/views/:viewId/order")
  .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}}/browser/views/:viewId/order');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/browser/views/:viewId/order'};

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

const url = '{{baseUrl}}/browser/views/:viewId/order';
const options = {method: 'PUT'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/browser/views/:viewId/order',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/order")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/browser/views/:viewId/order',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/browser/views/:viewId/order'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/browser/views/:viewId/order');

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}}/browser/views/:viewId/order'};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/order';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/browser/views/:viewId/order"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/browser/views/:viewId/order" in

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

 "{{baseUrl}}/browser/views/:viewId/order",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/browser/views/:viewId/order');

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/order');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/browser/views/:viewId/order');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/browser/views/:viewId/order' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/order' -Method PUT 

import http.client

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

conn.request("PUT", "/baseUrl/browser/views/:viewId/order")

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/order"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/order"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/browser/views/:viewId/order")

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

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

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

require 'faraday'

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

response = conn.put('/baseUrl/browser/views/:viewId/order') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/browser/views/:viewId/order

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/order

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/order")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId/permissions");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/browser/views/:viewId/permissions" {:content-type :json
                                                                             :form-params {:sharedGroups []}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/permissions"

	payload := strings.NewReader("{\n  \"sharedGroups\": []\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/browser/views/:viewId/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24

{
  "sharedGroups": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/browser/views/:viewId/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"sharedGroups\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.put("{{baseUrl}}/browser/views/:viewId/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"sharedGroups\": []\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/browser/views/:viewId/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/permissions',
  headers: {'content-type': 'application/json'},
  data: {sharedGroups: []}
};

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

const url = '{{baseUrl}}/browser/views/:viewId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"sharedGroups":[]}'
};

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}}/browser/views/:viewId/permissions',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "sharedGroups": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"sharedGroups\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/permissions")
  .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/browser/views/:viewId/permissions',
  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({sharedGroups: []}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/permissions',
  headers: {'content-type': 'application/json'},
  body: {sharedGroups: []},
  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}}/browser/views/:viewId/permissions');

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

req.type('json');
req.send({
  sharedGroups: []
});

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}}/browser/views/:viewId/permissions',
  headers: {'content-type': 'application/json'},
  data: {sharedGroups: []}
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"sharedGroups":[]}'
};

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

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

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

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

 "{{baseUrl}}/browser/views/:viewId/permissions",
  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([
    'sharedGroups' => [
        
    ]
  ]),
  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}}/browser/views/:viewId/permissions', [
  'body' => '{
  "sharedGroups": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/permissions');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'sharedGroups' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/browser/views/:viewId/permissions');
$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}}/browser/views/:viewId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "sharedGroups": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "sharedGroups": []
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/browser/views/:viewId/permissions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/permissions"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/permissions"

payload <- "{\n  \"sharedGroups\": []\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}}/browser/views/:viewId/permissions")

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  \"sharedGroups\": []\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/browser/views/:viewId/permissions') do |req|
  req.body = "{\n  \"sharedGroups\": []\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}}/browser/views/:viewId/permissions";

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

    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 '{
  "sharedGroups": []
}' |  \
  http PUT {{baseUrl}}/browser/views/:viewId/permissions \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "sharedGroups": []\n}' \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/permissions

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/browser/views/:viewId/settings");

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  \"local\": {\n    \"maxLinesInRow\": 0,\n    \"maxRows\": 0\n  },\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/browser/views/:viewId/settings" {:content-type :json
                                                                          :form-params {:local {:maxLinesInRow 0
                                                                                                :maxRows 0}
                                                                                        :name ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/browser/views/:viewId/settings"

	payload := strings.NewReader("{\n  \"local\": {\n    \"maxLinesInRow\": 0,\n    \"maxRows\": 0\n  },\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/browser/views/:viewId/settings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 75

{
  "local": {
    "maxLinesInRow": 0,
    "maxRows": 0
  },
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/browser/views/:viewId/settings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"local\": {\n    \"maxLinesInRow\": 0,\n    \"maxRows\": 0\n  },\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.put("{{baseUrl}}/browser/views/:viewId/settings")
  .header("content-type", "application/json")
  .body("{\n  \"local\": {\n    \"maxLinesInRow\": 0,\n    \"maxRows\": 0\n  },\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  local: {
    maxLinesInRow: 0,
    maxRows: 0
  },
  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}}/browser/views/:viewId/settings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/settings',
  headers: {'content-type': 'application/json'},
  data: {local: {maxLinesInRow: 0, maxRows: 0}, name: ''}
};

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

const url = '{{baseUrl}}/browser/views/:viewId/settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"local":{"maxLinesInRow":0,"maxRows":0},"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}}/browser/views/:viewId/settings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "local": {\n    "maxLinesInRow": 0,\n    "maxRows": 0\n  },\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  \"local\": {\n    \"maxLinesInRow\": 0,\n    \"maxRows\": 0\n  },\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/browser/views/:viewId/settings")
  .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/browser/views/:viewId/settings',
  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({local: {maxLinesInRow: 0, maxRows: 0}, name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/browser/views/:viewId/settings',
  headers: {'content-type': 'application/json'},
  body: {local: {maxLinesInRow: 0, maxRows: 0}, 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}}/browser/views/:viewId/settings');

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

req.type('json');
req.send({
  local: {
    maxLinesInRow: 0,
    maxRows: 0
  },
  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}}/browser/views/:viewId/settings',
  headers: {'content-type': 'application/json'},
  data: {local: {maxLinesInRow: 0, maxRows: 0}, name: ''}
};

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

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

const url = '{{baseUrl}}/browser/views/:viewId/settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"local":{"maxLinesInRow":0,"maxRows":0},"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 = @{ @"local": @{ @"maxLinesInRow": @0, @"maxRows": @0 },
                              @"name": @"" };

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

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

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

 "{{baseUrl}}/browser/views/:viewId/settings",
  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([
    'local' => [
        'maxLinesInRow' => 0,
        'maxRows' => 0
    ],
    '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}}/browser/views/:viewId/settings', [
  'body' => '{
  "local": {
    "maxLinesInRow": 0,
    "maxRows": 0
  },
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/browser/views/:viewId/settings');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'local' => [
    'maxLinesInRow' => 0,
    'maxRows' => 0
  ],
  'name' => ''
]));

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

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

append(json_encode([
  'local' => [
    'maxLinesInRow' => 0,
    'maxRows' => 0
  ],
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/browser/views/:viewId/settings');
$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}}/browser/views/:viewId/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "local": {
    "maxLinesInRow": 0,
    "maxRows": 0
  },
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/browser/views/:viewId/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "local": {
    "maxLinesInRow": 0,
    "maxRows": 0
  },
  "name": ""
}'

import http.client

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

payload = "{\n  \"local\": {\n    \"maxLinesInRow\": 0,\n    \"maxRows\": 0\n  },\n  \"name\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/browser/views/:viewId/settings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/browser/views/:viewId/settings"

payload = {
    "local": {
        "maxLinesInRow": 0,
        "maxRows": 0
    },
    "name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/browser/views/:viewId/settings"

payload <- "{\n  \"local\": {\n    \"maxLinesInRow\": 0,\n    \"maxRows\": 0\n  },\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}}/browser/views/:viewId/settings")

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  \"local\": {\n    \"maxLinesInRow\": 0,\n    \"maxRows\": 0\n  },\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/browser/views/:viewId/settings') do |req|
  req.body = "{\n  \"local\": {\n    \"maxLinesInRow\": 0,\n    \"maxRows\": 0\n  },\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}}/browser/views/:viewId/settings";

    let payload = json!({
        "local": json!({
            "maxLinesInRow": 0,
            "maxRows": 0
        }),
        "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 '{
  "local": {
    "maxLinesInRow": 0,
    "maxRows": 0
  },
  "name": ""
}' |  \
  http PUT {{baseUrl}}/browser/views/:viewId/settings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "local": {\n    "maxLinesInRow": 0,\n    "maxRows": 0\n  },\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/browser/views/:viewId/settings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "local": [
    "maxLinesInRow": 0,
    "maxRows": 0
  ],
  "name": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/browser/views/:viewId/settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments" {:body "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody"})

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"
headers = HTTP::Headers{
  "content-type" => "application/json;charset=UTF-8"
}
reqBody = "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody"

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}}/accounting/customers/invoices/:invoiceId/payments"),
    Content = new StringContent("/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("text/plain")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json;charset=UTF-8");
request.AddParameter("application/json;charset=UTF-8", "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"

	payload := strings.NewReader("/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody")

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

	req.Header.Add("content-type", "application/json;charset=UTF-8")

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

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/accounting/customers/invoices/:invoiceId/payments HTTP/1.1
Content-Type: application/json;charset=UTF-8
Host: example.com
Content-Length: 86

/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")
  .setHeader("content-type", "application/json;charset=UTF-8")
  .setBody("/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"))
    .header("content-type", "application/json;charset=UTF-8")
    .method("POST", HttpRequest.BodyPublishers.ofString("/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")
  .post(body)
  .addHeader("content-type", "application/json;charset=UTF-8")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")
  .header("content-type", "application/json;charset=UTF-8")
  .body("/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody")
  .asString();

const data = '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments');
xhr.setRequestHeader('content-type', 'application/json;charset=UTF-8');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments',
  headers: {'content-type': 'application/json;charset=UTF-8'},
  data: '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json;charset=UTF-8'},
  body: '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody'
};

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}}/accounting/customers/invoices/:invoiceId/payments',
  method: 'POST',
  headers: {
    'content-type': 'application/json;charset=UTF-8'
  },
  data: '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("text/plain")
val body = RequestBody.create(mediaType, "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody")
val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")
  .post(body)
  .addHeader("content-type", "application/json;charset=UTF-8")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId/payments',
  headers: {
    'content-type': 'application/json;charset=UTF-8'
  }
};

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('/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments',
  headers: {'content-type': 'application/json;charset=UTF-8'},
  body: '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments');

req.headers({
  'content-type': 'application/json;charset=UTF-8'
});

req.send('/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody');

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}}/accounting/customers/invoices/:invoiceId/payments',
  headers: {'content-type': 'application/json;charset=UTF-8'},
  data: '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json;charset=UTF-8'},
  body: '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody'
};

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;charset=UTF-8" };

NSData *postData = [[NSData alloc] initWithData:[@"/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"]
                                                       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}}/accounting/customers/invoices/:invoiceId/payments" in
let headers = Header.add (Header.init ()) "content-type" "application/json;charset=UTF-8" in
let body = Cohttp_lwt_body.of_string "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody",
  CURLOPT_HTTPHEADER => [
    "content-type: application/json;charset=UTF-8"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments', [
  'body' => '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody',
  'headers' => [
    'content-type' => 'application/json;charset=UTF-8',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json;charset=UTF-8'
]);

$request->setBody('/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append('/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody');

$request->setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json;charset=UTF-8'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json;charset=UTF-8")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments' -Method POST -Headers $headers -ContentType 'application/json;charset=UTF-8' -Body '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody'

$headers=@{}
$headers.Add("content-type", "application/json;charset=UTF-8")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments' -Method POST -Headers $headers -ContentType 'application/json;charset=UTF-8' -Body '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody"

headers = { 'content-type': "application/json;charset=UTF-8" }

conn.request("POST", "/baseUrl/accounting/customers/invoices/:invoiceId/payments", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"

payload = "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody"
headers = {"content-type": "application/json;charset=UTF-8"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"

payload <- "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody"

encode <- "raw"

response <- VERB("POST", url, body = payload, content_type("text/plain"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json;charset=UTF-8'
request.body = "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json;charset=UTF-8'}
)

response = conn.post('/baseUrl/accounting/customers/invoices/:invoiceId/payments') do |req|
  req.body = "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments";

    let payload = "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json;charset=UTF-8".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .body(payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody' |  \
  http POST {{baseUrl}}/accounting/customers/invoices/:invoiceId/payments \
  content-type:'application/json;charset=UTF-8'

wget --quiet \
  --method POST \
  --header 'content-type: application/json;charset=UTF-8' \
  --body-data '/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody' \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId/payments

import Foundation

let headers = ["content-type": "application/json;charset=UTF-8"]

let postData = NSData(data: "/home-api/assets/examples/accounting/customers/invoices/createPayment.json#requestBody".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")! 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}}/accounting/customers/invoices");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounting/customers/invoices")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/accounting/customers/invoices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/accounting/customers/invoices HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounting/customers/invoices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices"))
    .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}}/accounting/customers/invoices")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounting/customers/invoices")
  .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}}/accounting/customers/invoices');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounting/customers/invoices',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounting/customers/invoices');

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}}/accounting/customers/invoices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounting/customers/invoices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounting/customers/invoices" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounting/customers/invoices');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/accounting/customers/invoices")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/accounting/customers/invoices') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/accounting/customers/invoices

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/accounting/customers/invoices/:invoiceId/duplicate/proForma HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma"))
    .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}}/accounting/customers/invoices/:invoiceId/duplicate/proForma")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma")
  .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}}/accounting/customers/invoices/:invoiceId/duplicate/proForma');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId/duplicate/proForma',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma');

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}}/accounting/customers/invoices/:invoiceId/duplicate/proForma'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/accounting/customers/invoices/:invoiceId/duplicate/proForma")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/accounting/customers/invoices/:invoiceId/duplicate/proForma') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate/proForma")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/accounting/customers/invoices/:invoiceId/duplicate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate"))
    .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}}/accounting/customers/invoices/:invoiceId/duplicate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate")
  .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}}/accounting/customers/invoices/:invoiceId/duplicate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId/duplicate',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate');

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}}/accounting/customers/invoices/:invoiceId/duplicate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/accounting/customers/invoices/:invoiceId/duplicate")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/accounting/customers/invoices/:invoiceId/duplicate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId/duplicate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document"

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}}/accounting/customers/invoices/:invoiceId/document"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId/document");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document"

	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/accounting/customers/invoices/:invoiceId/document HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId/document"))
    .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}}/accounting/customers/invoices/:invoiceId/document")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounting/customers/invoices/:invoiceId/document")
  .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}}/accounting/customers/invoices/:invoiceId/document');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/document'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/document';
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}}/accounting/customers/invoices/:invoiceId/document',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId/document")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId/document',
  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}}/accounting/customers/invoices/:invoiceId/document'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/document');

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}}/accounting/customers/invoices/:invoiceId/document'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/document';
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}}/accounting/customers/invoices/:invoiceId/document"]
                                                       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}}/accounting/customers/invoices/:invoiceId/document" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document",
  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}}/accounting/customers/invoices/:invoiceId/document');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/document');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/document');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/document' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/document' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounting/customers/invoices/:invoiceId/document")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId/document")

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/accounting/customers/invoices/:invoiceId/document') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounting/customers/invoices/:invoiceId/document

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId/document

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId/document")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices/documents");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounting/customers/invoices/documents")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/documents"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/accounting/customers/invoices/documents"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/documents");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/documents"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/accounting/customers/invoices/documents HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounting/customers/invoices/documents")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/documents"))
    .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}}/accounting/customers/invoices/documents")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounting/customers/invoices/documents")
  .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}}/accounting/customers/invoices/documents');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/documents'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/documents';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounting/customers/invoices/documents',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/documents")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/documents',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/documents'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounting/customers/invoices/documents');

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}}/accounting/customers/invoices/documents'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/documents';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounting/customers/invoices/documents"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounting/customers/invoices/documents" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/documents",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounting/customers/invoices/documents');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/documents');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/documents');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/documents' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/documents' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/accounting/customers/invoices/documents")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/documents"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/documents"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/documents")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/accounting/customers/invoices/documents') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/documents";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/accounting/customers/invoices/documents

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/documents

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/documents")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounting/customers/invoices")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices"

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}}/accounting/customers/invoices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices"

	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/accounting/customers/invoices HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounting/customers/invoices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices"))
    .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}}/accounting/customers/invoices")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounting/customers/invoices")
  .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}}/accounting/customers/invoices');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounting/customers/invoices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices';
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}}/accounting/customers/invoices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices',
  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}}/accounting/customers/invoices'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounting/customers/invoices');

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}}/accounting/customers/invoices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices';
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}}/accounting/customers/invoices"]
                                                       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}}/accounting/customers/invoices" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices",
  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}}/accounting/customers/invoices');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounting/customers/invoices")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices")

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/accounting/customers/invoices') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounting/customers/invoices

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices/:invoiceId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounting/customers/invoices/:invoiceId")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId"

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}}/accounting/customers/invoices/:invoiceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId"

	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/accounting/customers/invoices/:invoiceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounting/customers/invoices/:invoiceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId"))
    .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}}/accounting/customers/invoices/:invoiceId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounting/customers/invoices/:invoiceId")
  .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}}/accounting/customers/invoices/:invoiceId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId';
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}}/accounting/customers/invoices/:invoiceId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId',
  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}}/accounting/customers/invoices/:invoiceId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounting/customers/invoices/:invoiceId');

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}}/accounting/customers/invoices/:invoiceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId';
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}}/accounting/customers/invoices/:invoiceId"]
                                                       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}}/accounting/customers/invoices/:invoiceId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId",
  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}}/accounting/customers/invoices/:invoiceId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounting/customers/invoices/:invoiceId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId")

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/accounting/customers/invoices/:invoiceId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId";

    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}}/accounting/customers/invoices/:invoiceId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/payments/:paymentId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounting/customers/payments/:paymentId")

require "http/client"

url = "{{baseUrl}}/accounting/customers/payments/:paymentId"

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}}/accounting/customers/payments/:paymentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/payments/:paymentId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/payments/:paymentId"

	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/accounting/customers/payments/:paymentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounting/customers/payments/:paymentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/payments/:paymentId"))
    .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}}/accounting/customers/payments/:paymentId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounting/customers/payments/:paymentId")
  .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}}/accounting/customers/payments/:paymentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounting/customers/payments/:paymentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/payments/:paymentId';
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}}/accounting/customers/payments/:paymentId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/payments/:paymentId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/payments/:paymentId',
  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}}/accounting/customers/payments/:paymentId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounting/customers/payments/:paymentId');

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}}/accounting/customers/payments/:paymentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/payments/:paymentId';
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}}/accounting/customers/payments/:paymentId"]
                                                       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}}/accounting/customers/payments/:paymentId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/payments/:paymentId",
  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}}/accounting/customers/payments/:paymentId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/payments/:paymentId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/payments/:paymentId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/payments/:paymentId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/payments/:paymentId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounting/customers/payments/:paymentId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/payments/:paymentId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/payments/:paymentId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/payments/:paymentId")

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/accounting/customers/payments/:paymentId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/payments/:paymentId";

    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}}/accounting/customers/payments/:paymentId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounting/customers/payments/:paymentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/payments/:paymentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"

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}}/accounting/customers/invoices/:invoiceId/payments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"

	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/accounting/customers/invoices/:invoiceId/payments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"))
    .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}}/accounting/customers/invoices/:invoiceId/payments")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")
  .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}}/accounting/customers/invoices/:invoiceId/payments');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments';
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}}/accounting/customers/invoices/:invoiceId/payments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId/payments',
  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}}/accounting/customers/invoices/:invoiceId/payments'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments');

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}}/accounting/customers/invoices/:invoiceId/payments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments';
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}}/accounting/customers/invoices/:invoiceId/payments"]
                                                       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}}/accounting/customers/invoices/:invoiceId/payments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments",
  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}}/accounting/customers/invoices/:invoiceId/payments');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounting/customers/invoices/:invoiceId/payments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")

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/accounting/customers/invoices/:invoiceId/payments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounting/customers/invoices/:invoiceId/payments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId/payments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId/payments")! 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}}/accounting/customers/invoices/:invoiceId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounting/customers/invoices/:invoiceId")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId"

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}}/accounting/customers/invoices/:invoiceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId"

	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/accounting/customers/invoices/:invoiceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounting/customers/invoices/:invoiceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId"))
    .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}}/accounting/customers/invoices/:invoiceId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounting/customers/invoices/:invoiceId")
  .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}}/accounting/customers/invoices/:invoiceId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId';
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}}/accounting/customers/invoices/:invoiceId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId',
  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}}/accounting/customers/invoices/:invoiceId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounting/customers/invoices/:invoiceId');

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}}/accounting/customers/invoices/:invoiceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId';
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}}/accounting/customers/invoices/:invoiceId"]
                                                       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}}/accounting/customers/invoices/:invoiceId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId",
  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}}/accounting/customers/invoices/:invoiceId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounting/customers/invoices/:invoiceId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId")

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/accounting/customers/invoices/:invoiceId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounting/customers/invoices/:invoiceId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId")! 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}}/accounting/customers/invoices/ids");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounting/customers/invoices/ids")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/ids"

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}}/accounting/customers/invoices/ids"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/ids");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/ids"

	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/accounting/customers/invoices/ids HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounting/customers/invoices/ids")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/ids"))
    .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}}/accounting/customers/invoices/ids")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounting/customers/invoices/ids")
  .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}}/accounting/customers/invoices/ids');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounting/customers/invoices/ids'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/ids';
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}}/accounting/customers/invoices/ids',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/ids")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/ids',
  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}}/accounting/customers/invoices/ids'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounting/customers/invoices/ids');

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}}/accounting/customers/invoices/ids'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/ids';
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}}/accounting/customers/invoices/ids"]
                                                       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}}/accounting/customers/invoices/ids" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/ids",
  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}}/accounting/customers/invoices/ids');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/ids');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/ids');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/ids' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/ids' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounting/customers/invoices/ids")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/ids"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/ids"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/ids")

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/accounting/customers/invoices/ids') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/ids";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounting/customers/invoices/ids

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/ids

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/ids")! 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}}/accounting/customers/invoices/:invoiceId/dates");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates"

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}}/accounting/customers/invoices/:invoiceId/dates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates"

	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/accounting/customers/invoices/:invoiceId/dates HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates"))
    .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}}/accounting/customers/invoices/:invoiceId/dates")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates")
  .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}}/accounting/customers/invoices/:invoiceId/dates');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates';
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}}/accounting/customers/invoices/:invoiceId/dates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId/dates',
  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}}/accounting/customers/invoices/:invoiceId/dates'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates');

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}}/accounting/customers/invoices/:invoiceId/dates'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates';
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}}/accounting/customers/invoices/:invoiceId/dates"]
                                                       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}}/accounting/customers/invoices/:invoiceId/dates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates",
  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}}/accounting/customers/invoices/:invoiceId/dates');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounting/customers/invoices/:invoiceId/dates")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates")

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/accounting/customers/invoices/:invoiceId/dates') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounting/customers/invoices/:invoiceId/dates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId/dates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId/dates")! 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}}/accounting/customers/invoices/:invoiceId/paymentTerms");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms"

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}}/accounting/customers/invoices/:invoiceId/paymentTerms"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms"

	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/accounting/customers/invoices/:invoiceId/paymentTerms HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms"))
    .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}}/accounting/customers/invoices/:invoiceId/paymentTerms")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms")
  .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}}/accounting/customers/invoices/:invoiceId/paymentTerms');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms';
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}}/accounting/customers/invoices/:invoiceId/paymentTerms',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId/paymentTerms',
  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}}/accounting/customers/invoices/:invoiceId/paymentTerms'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms');

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}}/accounting/customers/invoices/:invoiceId/paymentTerms'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms';
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}}/accounting/customers/invoices/:invoiceId/paymentTerms"]
                                                       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}}/accounting/customers/invoices/:invoiceId/paymentTerms" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms",
  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}}/accounting/customers/invoices/:invoiceId/paymentTerms');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounting/customers/invoices/:invoiceId/paymentTerms")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms")

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/accounting/customers/invoices/:invoiceId/paymentTerms') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId/paymentTerms")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/accounting/customers/invoices/:invoiceId/sendReminder HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder"))
    .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}}/accounting/customers/invoices/:invoiceId/sendReminder")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder")
  .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}}/accounting/customers/invoices/:invoiceId/sendReminder');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/:invoiceId/sendReminder',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder');

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}}/accounting/customers/invoices/:invoiceId/sendReminder'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/accounting/customers/invoices/:invoiceId/sendReminder")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/accounting/customers/invoices/:invoiceId/sendReminder') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/:invoiceId/sendReminder")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounting/customers/invoices/sendReminders");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounting/customers/invoices/sendReminders")

require "http/client"

url = "{{baseUrl}}/accounting/customers/invoices/sendReminders"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/accounting/customers/invoices/sendReminders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounting/customers/invoices/sendReminders");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounting/customers/invoices/sendReminders"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/accounting/customers/invoices/sendReminders HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounting/customers/invoices/sendReminders")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounting/customers/invoices/sendReminders"))
    .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}}/accounting/customers/invoices/sendReminders")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounting/customers/invoices/sendReminders")
  .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}}/accounting/customers/invoices/sendReminders');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/sendReminders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounting/customers/invoices/sendReminders';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounting/customers/invoices/sendReminders',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounting/customers/invoices/sendReminders")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounting/customers/invoices/sendReminders',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounting/customers/invoices/sendReminders'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounting/customers/invoices/sendReminders');

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}}/accounting/customers/invoices/sendReminders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounting/customers/invoices/sendReminders';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounting/customers/invoices/sendReminders"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounting/customers/invoices/sendReminders" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounting/customers/invoices/sendReminders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounting/customers/invoices/sendReminders');

echo $response->getBody();

setUrl('{{baseUrl}}/accounting/customers/invoices/sendReminders');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounting/customers/invoices/sendReminders');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounting/customers/invoices/sendReminders' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounting/customers/invoices/sendReminders' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/accounting/customers/invoices/sendReminders")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounting/customers/invoices/sendReminders"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounting/customers/invoices/sendReminders"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounting/customers/invoices/sendReminders")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/accounting/customers/invoices/sendReminders') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounting/customers/invoices/sendReminders";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/accounting/customers/invoices/sendReminders

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/accounting/customers/invoices/sendReminders

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounting/customers/invoices/sendReminders")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers");

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  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/customers" {:content-type :json
                                                      :form-params {:accountOnCustomerServer ""
                                                                    :accounting {:taxNumbers [{:number ""
                                                                                               :type ""}]}
                                                                    :billingAddress {:addressLine1 ""
                                                                                     :addressLine2 ""
                                                                                     :city ""
                                                                                     :countryId 0
                                                                                     :postalCode ""
                                                                                     :provinceId 0
                                                                                     :sameAsBillingAddress false}
                                                                    :branchId 0
                                                                    :categoriesIds []
                                                                    :clientFirstProjectDate ""
                                                                    :clientFirstQuoteDate ""
                                                                    :clientLastProjectDate ""
                                                                    :clientLastQuoteDate ""
                                                                    :clientNumberOfProjects 0
                                                                    :clientNumberOfQuotes 0
                                                                    :contact {:emails {:additional []
                                                                                       :cc []
                                                                                       :primary ""}
                                                                              :fax ""
                                                                              :phones []
                                                                              :sms ""
                                                                              :websites []}
                                                                    :contractNumber ""
                                                                    :correspondenceAddress {}
                                                                    :customFields [{:key ""
                                                                                    :name ""
                                                                                    :type ""
                                                                                    :value {}}]
                                                                    :fullName ""
                                                                    :id 0
                                                                    :idNumber ""
                                                                    :industriesIds []
                                                                    :leadSourceId 0
                                                                    :limitAccessToPeopleResponsible false
                                                                    :name ""
                                                                    :notes ""
                                                                    :persons [{:active false
                                                                               :contact {:emails {:additional []
                                                                                                  :primary ""}
                                                                                         :fax ""
                                                                                         :phones []
                                                                                         :sms ""}
                                                                               :customFields [{}]
                                                                               :customerId 0
                                                                               :firstProjectDate ""
                                                                               :firstQuoteDate ""
                                                                               :gender ""
                                                                               :id 0
                                                                               :lastName ""
                                                                               :lastProjectDate ""
                                                                               :lastQuoteDate ""
                                                                               :motherTonguesIds []
                                                                               :name ""
                                                                               :numberOfProjects 0
                                                                               :numberOfQuotes 0
                                                                               :positionId 0}]
                                                                    :responsiblePersons {:accountManagerId 0
                                                                                         :projectCoordinatorId 0
                                                                                         :projectManagerId 0
                                                                                         :salesPersonId 0}
                                                                    :salesNotes ""
                                                                    :status ""}})

require "http/client"

url = "{{baseUrl}}/customers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\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}}/customers"),
    Content = new StringContent("{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\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}}/customers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers"

	payload := strings.NewReader("{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\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/customers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1811

{
  "accountOnCustomerServer": "",
  "accounting": {
    "taxNumbers": [
      {
        "number": "",
        "type": ""
      }
    ]
  },
  "billingAddress": {
    "addressLine1": "",
    "addressLine2": "",
    "city": "",
    "countryId": 0,
    "postalCode": "",
    "provinceId": 0,
    "sameAsBillingAddress": false
  },
  "branchId": 0,
  "categoriesIds": [],
  "clientFirstProjectDate": "",
  "clientFirstQuoteDate": "",
  "clientLastProjectDate": "",
  "clientLastQuoteDate": "",
  "clientNumberOfProjects": 0,
  "clientNumberOfQuotes": 0,
  "contact": {
    "emails": {
      "additional": [],
      "cc": [],
      "primary": ""
    },
    "fax": "",
    "phones": [],
    "sms": "",
    "websites": []
  },
  "contractNumber": "",
  "correspondenceAddress": {},
  "customFields": [
    {
      "key": "",
      "name": "",
      "type": "",
      "value": {}
    }
  ],
  "fullName": "",
  "id": 0,
  "idNumber": "",
  "industriesIds": [],
  "leadSourceId": 0,
  "limitAccessToPeopleResponsible": false,
  "name": "",
  "notes": "",
  "persons": [
    {
      "active": false,
      "contact": {
        "emails": {
          "additional": [],
          "primary": ""
        },
        "fax": "",
        "phones": [],
        "sms": ""
      },
      "customFields": [
        {}
      ],
      "customerId": 0,
      "firstProjectDate": "",
      "firstQuoteDate": "",
      "gender": "",
      "id": 0,
      "lastName": "",
      "lastProjectDate": "",
      "lastQuoteDate": "",
      "motherTonguesIds": [],
      "name": "",
      "numberOfProjects": 0,
      "numberOfQuotes": 0,
      "positionId": 0
    }
  ],
  "responsiblePersons": {
    "accountManagerId": 0,
    "projectCoordinatorId": 0,
    "projectManagerId": 0,
    "salesPersonId": 0
  },
  "salesNotes": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/customers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\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  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/customers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/customers")
  .header("content-type", "application/json")
  .body("{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  accountOnCustomerServer: '',
  accounting: {
    taxNumbers: [
      {
        number: '',
        type: ''
      }
    ]
  },
  billingAddress: {
    addressLine1: '',
    addressLine2: '',
    city: '',
    countryId: 0,
    postalCode: '',
    provinceId: 0,
    sameAsBillingAddress: false
  },
  branchId: 0,
  categoriesIds: [],
  clientFirstProjectDate: '',
  clientFirstQuoteDate: '',
  clientLastProjectDate: '',
  clientLastQuoteDate: '',
  clientNumberOfProjects: 0,
  clientNumberOfQuotes: 0,
  contact: {
    emails: {
      additional: [],
      cc: [],
      primary: ''
    },
    fax: '',
    phones: [],
    sms: '',
    websites: []
  },
  contractNumber: '',
  correspondenceAddress: {},
  customFields: [
    {
      key: '',
      name: '',
      type: '',
      value: {}
    }
  ],
  fullName: '',
  id: 0,
  idNumber: '',
  industriesIds: [],
  leadSourceId: 0,
  limitAccessToPeopleResponsible: false,
  name: '',
  notes: '',
  persons: [
    {
      active: false,
      contact: {
        emails: {
          additional: [],
          primary: ''
        },
        fax: '',
        phones: [],
        sms: ''
      },
      customFields: [
        {}
      ],
      customerId: 0,
      firstProjectDate: '',
      firstQuoteDate: '',
      gender: '',
      id: 0,
      lastName: '',
      lastProjectDate: '',
      lastQuoteDate: '',
      motherTonguesIds: [],
      name: '',
      numberOfProjects: 0,
      numberOfQuotes: 0,
      positionId: 0
    }
  ],
  responsiblePersons: {
    accountManagerId: 0,
    projectCoordinatorId: 0,
    projectManagerId: 0,
    salesPersonId: 0
  },
  salesNotes: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/customers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers',
  headers: {'content-type': 'application/json'},
  data: {
    accountOnCustomerServer: '',
    accounting: {taxNumbers: [{number: '', type: ''}]},
    billingAddress: {
      addressLine1: '',
      addressLine2: '',
      city: '',
      countryId: 0,
      postalCode: '',
      provinceId: 0,
      sameAsBillingAddress: false
    },
    branchId: 0,
    categoriesIds: [],
    clientFirstProjectDate: '',
    clientFirstQuoteDate: '',
    clientLastProjectDate: '',
    clientLastQuoteDate: '',
    clientNumberOfProjects: 0,
    clientNumberOfQuotes: 0,
    contact: {
      emails: {additional: [], cc: [], primary: ''},
      fax: '',
      phones: [],
      sms: '',
      websites: []
    },
    contractNumber: '',
    correspondenceAddress: {},
    customFields: [{key: '', name: '', type: '', value: {}}],
    fullName: '',
    id: 0,
    idNumber: '',
    industriesIds: [],
    leadSourceId: 0,
    limitAccessToPeopleResponsible: false,
    name: '',
    notes: '',
    persons: [
      {
        active: false,
        contact: {emails: {additional: [], primary: ''}, fax: '', phones: [], sms: ''},
        customFields: [{}],
        customerId: 0,
        firstProjectDate: '',
        firstQuoteDate: '',
        gender: '',
        id: 0,
        lastName: '',
        lastProjectDate: '',
        lastQuoteDate: '',
        motherTonguesIds: [],
        name: '',
        numberOfProjects: 0,
        numberOfQuotes: 0,
        positionId: 0
      }
    ],
    responsiblePersons: {
      accountManagerId: 0,
      projectCoordinatorId: 0,
      projectManagerId: 0,
      salesPersonId: 0
    },
    salesNotes: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"accountOnCustomerServer":"","accounting":{"taxNumbers":[{"number":"","type":""}]},"billingAddress":{"addressLine1":"","addressLine2":"","city":"","countryId":0,"postalCode":"","provinceId":0,"sameAsBillingAddress":false},"branchId":0,"categoriesIds":[],"clientFirstProjectDate":"","clientFirstQuoteDate":"","clientLastProjectDate":"","clientLastQuoteDate":"","clientNumberOfProjects":0,"clientNumberOfQuotes":0,"contact":{"emails":{"additional":[],"cc":[],"primary":""},"fax":"","phones":[],"sms":"","websites":[]},"contractNumber":"","correspondenceAddress":{},"customFields":[{"key":"","name":"","type":"","value":{}}],"fullName":"","id":0,"idNumber":"","industriesIds":[],"leadSourceId":0,"limitAccessToPeopleResponsible":false,"name":"","notes":"","persons":[{"active":false,"contact":{"emails":{"additional":[],"primary":""},"fax":"","phones":[],"sms":""},"customFields":[{}],"customerId":0,"firstProjectDate":"","firstQuoteDate":"","gender":"","id":0,"lastName":"","lastProjectDate":"","lastQuoteDate":"","motherTonguesIds":[],"name":"","numberOfProjects":0,"numberOfQuotes":0,"positionId":0}],"responsiblePersons":{"accountManagerId":0,"projectCoordinatorId":0,"projectManagerId":0,"salesPersonId":0},"salesNotes":"","status":""}'
};

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}}/customers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accountOnCustomerServer": "",\n  "accounting": {\n    "taxNumbers": [\n      {\n        "number": "",\n        "type": ""\n      }\n    ]\n  },\n  "billingAddress": {\n    "addressLine1": "",\n    "addressLine2": "",\n    "city": "",\n    "countryId": 0,\n    "postalCode": "",\n    "provinceId": 0,\n    "sameAsBillingAddress": false\n  },\n  "branchId": 0,\n  "categoriesIds": [],\n  "clientFirstProjectDate": "",\n  "clientFirstQuoteDate": "",\n  "clientLastProjectDate": "",\n  "clientLastQuoteDate": "",\n  "clientNumberOfProjects": 0,\n  "clientNumberOfQuotes": 0,\n  "contact": {\n    "emails": {\n      "additional": [],\n      "cc": [],\n      "primary": ""\n    },\n    "fax": "",\n    "phones": [],\n    "sms": "",\n    "websites": []\n  },\n  "contractNumber": "",\n  "correspondenceAddress": {},\n  "customFields": [\n    {\n      "key": "",\n      "name": "",\n      "type": "",\n      "value": {}\n    }\n  ],\n  "fullName": "",\n  "id": 0,\n  "idNumber": "",\n  "industriesIds": [],\n  "leadSourceId": 0,\n  "limitAccessToPeopleResponsible": false,\n  "name": "",\n  "notes": "",\n  "persons": [\n    {\n      "active": false,\n      "contact": {\n        "emails": {\n          "additional": [],\n          "primary": ""\n        },\n        "fax": "",\n        "phones": [],\n        "sms": ""\n      },\n      "customFields": [\n        {}\n      ],\n      "customerId": 0,\n      "firstProjectDate": "",\n      "firstQuoteDate": "",\n      "gender": "",\n      "id": 0,\n      "lastName": "",\n      "lastProjectDate": "",\n      "lastQuoteDate": "",\n      "motherTonguesIds": [],\n      "name": "",\n      "numberOfProjects": 0,\n      "numberOfQuotes": 0,\n      "positionId": 0\n    }\n  ],\n  "responsiblePersons": {\n    "accountManagerId": 0,\n    "projectCoordinatorId": 0,\n    "projectManagerId": 0,\n    "salesPersonId": 0\n  },\n  "salesNotes": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/customers")
  .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/customers',
  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({
  accountOnCustomerServer: '',
  accounting: {taxNumbers: [{number: '', type: ''}]},
  billingAddress: {
    addressLine1: '',
    addressLine2: '',
    city: '',
    countryId: 0,
    postalCode: '',
    provinceId: 0,
    sameAsBillingAddress: false
  },
  branchId: 0,
  categoriesIds: [],
  clientFirstProjectDate: '',
  clientFirstQuoteDate: '',
  clientLastProjectDate: '',
  clientLastQuoteDate: '',
  clientNumberOfProjects: 0,
  clientNumberOfQuotes: 0,
  contact: {
    emails: {additional: [], cc: [], primary: ''},
    fax: '',
    phones: [],
    sms: '',
    websites: []
  },
  contractNumber: '',
  correspondenceAddress: {},
  customFields: [{key: '', name: '', type: '', value: {}}],
  fullName: '',
  id: 0,
  idNumber: '',
  industriesIds: [],
  leadSourceId: 0,
  limitAccessToPeopleResponsible: false,
  name: '',
  notes: '',
  persons: [
    {
      active: false,
      contact: {emails: {additional: [], primary: ''}, fax: '', phones: [], sms: ''},
      customFields: [{}],
      customerId: 0,
      firstProjectDate: '',
      firstQuoteDate: '',
      gender: '',
      id: 0,
      lastName: '',
      lastProjectDate: '',
      lastQuoteDate: '',
      motherTonguesIds: [],
      name: '',
      numberOfProjects: 0,
      numberOfQuotes: 0,
      positionId: 0
    }
  ],
  responsiblePersons: {
    accountManagerId: 0,
    projectCoordinatorId: 0,
    projectManagerId: 0,
    salesPersonId: 0
  },
  salesNotes: '',
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers',
  headers: {'content-type': 'application/json'},
  body: {
    accountOnCustomerServer: '',
    accounting: {taxNumbers: [{number: '', type: ''}]},
    billingAddress: {
      addressLine1: '',
      addressLine2: '',
      city: '',
      countryId: 0,
      postalCode: '',
      provinceId: 0,
      sameAsBillingAddress: false
    },
    branchId: 0,
    categoriesIds: [],
    clientFirstProjectDate: '',
    clientFirstQuoteDate: '',
    clientLastProjectDate: '',
    clientLastQuoteDate: '',
    clientNumberOfProjects: 0,
    clientNumberOfQuotes: 0,
    contact: {
      emails: {additional: [], cc: [], primary: ''},
      fax: '',
      phones: [],
      sms: '',
      websites: []
    },
    contractNumber: '',
    correspondenceAddress: {},
    customFields: [{key: '', name: '', type: '', value: {}}],
    fullName: '',
    id: 0,
    idNumber: '',
    industriesIds: [],
    leadSourceId: 0,
    limitAccessToPeopleResponsible: false,
    name: '',
    notes: '',
    persons: [
      {
        active: false,
        contact: {emails: {additional: [], primary: ''}, fax: '', phones: [], sms: ''},
        customFields: [{}],
        customerId: 0,
        firstProjectDate: '',
        firstQuoteDate: '',
        gender: '',
        id: 0,
        lastName: '',
        lastProjectDate: '',
        lastQuoteDate: '',
        motherTonguesIds: [],
        name: '',
        numberOfProjects: 0,
        numberOfQuotes: 0,
        positionId: 0
      }
    ],
    responsiblePersons: {
      accountManagerId: 0,
      projectCoordinatorId: 0,
      projectManagerId: 0,
      salesPersonId: 0
    },
    salesNotes: '',
    status: ''
  },
  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}}/customers');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  accountOnCustomerServer: '',
  accounting: {
    taxNumbers: [
      {
        number: '',
        type: ''
      }
    ]
  },
  billingAddress: {
    addressLine1: '',
    addressLine2: '',
    city: '',
    countryId: 0,
    postalCode: '',
    provinceId: 0,
    sameAsBillingAddress: false
  },
  branchId: 0,
  categoriesIds: [],
  clientFirstProjectDate: '',
  clientFirstQuoteDate: '',
  clientLastProjectDate: '',
  clientLastQuoteDate: '',
  clientNumberOfProjects: 0,
  clientNumberOfQuotes: 0,
  contact: {
    emails: {
      additional: [],
      cc: [],
      primary: ''
    },
    fax: '',
    phones: [],
    sms: '',
    websites: []
  },
  contractNumber: '',
  correspondenceAddress: {},
  customFields: [
    {
      key: '',
      name: '',
      type: '',
      value: {}
    }
  ],
  fullName: '',
  id: 0,
  idNumber: '',
  industriesIds: [],
  leadSourceId: 0,
  limitAccessToPeopleResponsible: false,
  name: '',
  notes: '',
  persons: [
    {
      active: false,
      contact: {
        emails: {
          additional: [],
          primary: ''
        },
        fax: '',
        phones: [],
        sms: ''
      },
      customFields: [
        {}
      ],
      customerId: 0,
      firstProjectDate: '',
      firstQuoteDate: '',
      gender: '',
      id: 0,
      lastName: '',
      lastProjectDate: '',
      lastQuoteDate: '',
      motherTonguesIds: [],
      name: '',
      numberOfProjects: 0,
      numberOfQuotes: 0,
      positionId: 0
    }
  ],
  responsiblePersons: {
    accountManagerId: 0,
    projectCoordinatorId: 0,
    projectManagerId: 0,
    salesPersonId: 0
  },
  salesNotes: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers',
  headers: {'content-type': 'application/json'},
  data: {
    accountOnCustomerServer: '',
    accounting: {taxNumbers: [{number: '', type: ''}]},
    billingAddress: {
      addressLine1: '',
      addressLine2: '',
      city: '',
      countryId: 0,
      postalCode: '',
      provinceId: 0,
      sameAsBillingAddress: false
    },
    branchId: 0,
    categoriesIds: [],
    clientFirstProjectDate: '',
    clientFirstQuoteDate: '',
    clientLastProjectDate: '',
    clientLastQuoteDate: '',
    clientNumberOfProjects: 0,
    clientNumberOfQuotes: 0,
    contact: {
      emails: {additional: [], cc: [], primary: ''},
      fax: '',
      phones: [],
      sms: '',
      websites: []
    },
    contractNumber: '',
    correspondenceAddress: {},
    customFields: [{key: '', name: '', type: '', value: {}}],
    fullName: '',
    id: 0,
    idNumber: '',
    industriesIds: [],
    leadSourceId: 0,
    limitAccessToPeopleResponsible: false,
    name: '',
    notes: '',
    persons: [
      {
        active: false,
        contact: {emails: {additional: [], primary: ''}, fax: '', phones: [], sms: ''},
        customFields: [{}],
        customerId: 0,
        firstProjectDate: '',
        firstQuoteDate: '',
        gender: '',
        id: 0,
        lastName: '',
        lastProjectDate: '',
        lastQuoteDate: '',
        motherTonguesIds: [],
        name: '',
        numberOfProjects: 0,
        numberOfQuotes: 0,
        positionId: 0
      }
    ],
    responsiblePersons: {
      accountManagerId: 0,
      projectCoordinatorId: 0,
      projectManagerId: 0,
      salesPersonId: 0
    },
    salesNotes: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"accountOnCustomerServer":"","accounting":{"taxNumbers":[{"number":"","type":""}]},"billingAddress":{"addressLine1":"","addressLine2":"","city":"","countryId":0,"postalCode":"","provinceId":0,"sameAsBillingAddress":false},"branchId":0,"categoriesIds":[],"clientFirstProjectDate":"","clientFirstQuoteDate":"","clientLastProjectDate":"","clientLastQuoteDate":"","clientNumberOfProjects":0,"clientNumberOfQuotes":0,"contact":{"emails":{"additional":[],"cc":[],"primary":""},"fax":"","phones":[],"sms":"","websites":[]},"contractNumber":"","correspondenceAddress":{},"customFields":[{"key":"","name":"","type":"","value":{}}],"fullName":"","id":0,"idNumber":"","industriesIds":[],"leadSourceId":0,"limitAccessToPeopleResponsible":false,"name":"","notes":"","persons":[{"active":false,"contact":{"emails":{"additional":[],"primary":""},"fax":"","phones":[],"sms":""},"customFields":[{}],"customerId":0,"firstProjectDate":"","firstQuoteDate":"","gender":"","id":0,"lastName":"","lastProjectDate":"","lastQuoteDate":"","motherTonguesIds":[],"name":"","numberOfProjects":0,"numberOfQuotes":0,"positionId":0}],"responsiblePersons":{"accountManagerId":0,"projectCoordinatorId":0,"projectManagerId":0,"salesPersonId":0},"salesNotes":"","status":""}'
};

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 = @{ @"accountOnCustomerServer": @"",
                              @"accounting": @{ @"taxNumbers": @[ @{ @"number": @"", @"type": @"" } ] },
                              @"billingAddress": @{ @"addressLine1": @"", @"addressLine2": @"", @"city": @"", @"countryId": @0, @"postalCode": @"", @"provinceId": @0, @"sameAsBillingAddress": @NO },
                              @"branchId": @0,
                              @"categoriesIds": @[  ],
                              @"clientFirstProjectDate": @"",
                              @"clientFirstQuoteDate": @"",
                              @"clientLastProjectDate": @"",
                              @"clientLastQuoteDate": @"",
                              @"clientNumberOfProjects": @0,
                              @"clientNumberOfQuotes": @0,
                              @"contact": @{ @"emails": @{ @"additional": @[  ], @"cc": @[  ], @"primary": @"" }, @"fax": @"", @"phones": @[  ], @"sms": @"", @"websites": @[  ] },
                              @"contractNumber": @"",
                              @"correspondenceAddress": @{  },
                              @"customFields": @[ @{ @"key": @"", @"name": @"", @"type": @"", @"value": @{  } } ],
                              @"fullName": @"",
                              @"id": @0,
                              @"idNumber": @"",
                              @"industriesIds": @[  ],
                              @"leadSourceId": @0,
                              @"limitAccessToPeopleResponsible": @NO,
                              @"name": @"",
                              @"notes": @"",
                              @"persons": @[ @{ @"active": @NO, @"contact": @{ @"emails": @{ @"additional": @[  ], @"primary": @"" }, @"fax": @"", @"phones": @[  ], @"sms": @"" }, @"customFields": @[ @{  } ], @"customerId": @0, @"firstProjectDate": @"", @"firstQuoteDate": @"", @"gender": @"", @"id": @0, @"lastName": @"", @"lastProjectDate": @"", @"lastQuoteDate": @"", @"motherTonguesIds": @[  ], @"name": @"", @"numberOfProjects": @0, @"numberOfQuotes": @0, @"positionId": @0 } ],
                              @"responsiblePersons": @{ @"accountManagerId": @0, @"projectCoordinatorId": @0, @"projectManagerId": @0, @"salesPersonId": @0 },
                              @"salesNotes": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers"]
                                                       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}}/customers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers",
  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([
    'accountOnCustomerServer' => '',
    'accounting' => [
        'taxNumbers' => [
                [
                                'number' => '',
                                'type' => ''
                ]
        ]
    ],
    'billingAddress' => [
        'addressLine1' => '',
        'addressLine2' => '',
        'city' => '',
        'countryId' => 0,
        'postalCode' => '',
        'provinceId' => 0,
        'sameAsBillingAddress' => null
    ],
    'branchId' => 0,
    'categoriesIds' => [
        
    ],
    'clientFirstProjectDate' => '',
    'clientFirstQuoteDate' => '',
    'clientLastProjectDate' => '',
    'clientLastQuoteDate' => '',
    'clientNumberOfProjects' => 0,
    'clientNumberOfQuotes' => 0,
    'contact' => [
        'emails' => [
                'additional' => [
                                
                ],
                'cc' => [
                                
                ],
                'primary' => ''
        ],
        'fax' => '',
        'phones' => [
                
        ],
        'sms' => '',
        'websites' => [
                
        ]
    ],
    'contractNumber' => '',
    'correspondenceAddress' => [
        
    ],
    'customFields' => [
        [
                'key' => '',
                'name' => '',
                'type' => '',
                'value' => [
                                
                ]
        ]
    ],
    'fullName' => '',
    'id' => 0,
    'idNumber' => '',
    'industriesIds' => [
        
    ],
    'leadSourceId' => 0,
    'limitAccessToPeopleResponsible' => null,
    'name' => '',
    'notes' => '',
    'persons' => [
        [
                'active' => null,
                'contact' => [
                                'emails' => [
                                                                'additional' => [
                                                                                                                                
                                                                ],
                                                                'primary' => ''
                                ],
                                'fax' => '',
                                'phones' => [
                                                                
                                ],
                                'sms' => ''
                ],
                'customFields' => [
                                [
                                                                
                                ]
                ],
                'customerId' => 0,
                'firstProjectDate' => '',
                'firstQuoteDate' => '',
                'gender' => '',
                'id' => 0,
                'lastName' => '',
                'lastProjectDate' => '',
                'lastQuoteDate' => '',
                'motherTonguesIds' => [
                                
                ],
                'name' => '',
                'numberOfProjects' => 0,
                'numberOfQuotes' => 0,
                'positionId' => 0
        ]
    ],
    'responsiblePersons' => [
        'accountManagerId' => 0,
        'projectCoordinatorId' => 0,
        'projectManagerId' => 0,
        'salesPersonId' => 0
    ],
    'salesNotes' => '',
    'status' => ''
  ]),
  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}}/customers', [
  'body' => '{
  "accountOnCustomerServer": "",
  "accounting": {
    "taxNumbers": [
      {
        "number": "",
        "type": ""
      }
    ]
  },
  "billingAddress": {
    "addressLine1": "",
    "addressLine2": "",
    "city": "",
    "countryId": 0,
    "postalCode": "",
    "provinceId": 0,
    "sameAsBillingAddress": false
  },
  "branchId": 0,
  "categoriesIds": [],
  "clientFirstProjectDate": "",
  "clientFirstQuoteDate": "",
  "clientLastProjectDate": "",
  "clientLastQuoteDate": "",
  "clientNumberOfProjects": 0,
  "clientNumberOfQuotes": 0,
  "contact": {
    "emails": {
      "additional": [],
      "cc": [],
      "primary": ""
    },
    "fax": "",
    "phones": [],
    "sms": "",
    "websites": []
  },
  "contractNumber": "",
  "correspondenceAddress": {},
  "customFields": [
    {
      "key": "",
      "name": "",
      "type": "",
      "value": {}
    }
  ],
  "fullName": "",
  "id": 0,
  "idNumber": "",
  "industriesIds": [],
  "leadSourceId": 0,
  "limitAccessToPeopleResponsible": false,
  "name": "",
  "notes": "",
  "persons": [
    {
      "active": false,
      "contact": {
        "emails": {
          "additional": [],
          "primary": ""
        },
        "fax": "",
        "phones": [],
        "sms": ""
      },
      "customFields": [
        {}
      ],
      "customerId": 0,
      "firstProjectDate": "",
      "firstQuoteDate": "",
      "gender": "",
      "id": 0,
      "lastName": "",
      "lastProjectDate": "",
      "lastQuoteDate": "",
      "motherTonguesIds": [],
      "name": "",
      "numberOfProjects": 0,
      "numberOfQuotes": 0,
      "positionId": 0
    }
  ],
  "responsiblePersons": {
    "accountManagerId": 0,
    "projectCoordinatorId": 0,
    "projectManagerId": 0,
    "salesPersonId": 0
  },
  "salesNotes": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/customers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountOnCustomerServer' => '',
  'accounting' => [
    'taxNumbers' => [
        [
                'number' => '',
                'type' => ''
        ]
    ]
  ],
  'billingAddress' => [
    'addressLine1' => '',
    'addressLine2' => '',
    'city' => '',
    'countryId' => 0,
    'postalCode' => '',
    'provinceId' => 0,
    'sameAsBillingAddress' => null
  ],
  'branchId' => 0,
  'categoriesIds' => [
    
  ],
  'clientFirstProjectDate' => '',
  'clientFirstQuoteDate' => '',
  'clientLastProjectDate' => '',
  'clientLastQuoteDate' => '',
  'clientNumberOfProjects' => 0,
  'clientNumberOfQuotes' => 0,
  'contact' => [
    'emails' => [
        'additional' => [
                
        ],
        'cc' => [
                
        ],
        'primary' => ''
    ],
    'fax' => '',
    'phones' => [
        
    ],
    'sms' => '',
    'websites' => [
        
    ]
  ],
  'contractNumber' => '',
  'correspondenceAddress' => [
    
  ],
  'customFields' => [
    [
        'key' => '',
        'name' => '',
        'type' => '',
        'value' => [
                
        ]
    ]
  ],
  'fullName' => '',
  'id' => 0,
  'idNumber' => '',
  'industriesIds' => [
    
  ],
  'leadSourceId' => 0,
  'limitAccessToPeopleResponsible' => null,
  'name' => '',
  'notes' => '',
  'persons' => [
    [
        'active' => null,
        'contact' => [
                'emails' => [
                                'additional' => [
                                                                
                                ],
                                'primary' => ''
                ],
                'fax' => '',
                'phones' => [
                                
                ],
                'sms' => ''
        ],
        'customFields' => [
                [
                                
                ]
        ],
        'customerId' => 0,
        'firstProjectDate' => '',
        'firstQuoteDate' => '',
        'gender' => '',
        'id' => 0,
        'lastName' => '',
        'lastProjectDate' => '',
        'lastQuoteDate' => '',
        'motherTonguesIds' => [
                
        ],
        'name' => '',
        'numberOfProjects' => 0,
        'numberOfQuotes' => 0,
        'positionId' => 0
    ]
  ],
  'responsiblePersons' => [
    'accountManagerId' => 0,
    'projectCoordinatorId' => 0,
    'projectManagerId' => 0,
    'salesPersonId' => 0
  ],
  'salesNotes' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'accountOnCustomerServer' => '',
  'accounting' => [
    'taxNumbers' => [
        [
                'number' => '',
                'type' => ''
        ]
    ]
  ],
  'billingAddress' => [
    'addressLine1' => '',
    'addressLine2' => '',
    'city' => '',
    'countryId' => 0,
    'postalCode' => '',
    'provinceId' => 0,
    'sameAsBillingAddress' => null
  ],
  'branchId' => 0,
  'categoriesIds' => [
    
  ],
  'clientFirstProjectDate' => '',
  'clientFirstQuoteDate' => '',
  'clientLastProjectDate' => '',
  'clientLastQuoteDate' => '',
  'clientNumberOfProjects' => 0,
  'clientNumberOfQuotes' => 0,
  'contact' => [
    'emails' => [
        'additional' => [
                
        ],
        'cc' => [
                
        ],
        'primary' => ''
    ],
    'fax' => '',
    'phones' => [
        
    ],
    'sms' => '',
    'websites' => [
        
    ]
  ],
  'contractNumber' => '',
  'correspondenceAddress' => [
    
  ],
  'customFields' => [
    [
        'key' => '',
        'name' => '',
        'type' => '',
        'value' => [
                
        ]
    ]
  ],
  'fullName' => '',
  'id' => 0,
  'idNumber' => '',
  'industriesIds' => [
    
  ],
  'leadSourceId' => 0,
  'limitAccessToPeopleResponsible' => null,
  'name' => '',
  'notes' => '',
  'persons' => [
    [
        'active' => null,
        'contact' => [
                'emails' => [
                                'additional' => [
                                                                
                                ],
                                'primary' => ''
                ],
                'fax' => '',
                'phones' => [
                                
                ],
                'sms' => ''
        ],
        'customFields' => [
                [
                                
                ]
        ],
        'customerId' => 0,
        'firstProjectDate' => '',
        'firstQuoteDate' => '',
        'gender' => '',
        'id' => 0,
        'lastName' => '',
        'lastProjectDate' => '',
        'lastQuoteDate' => '',
        'motherTonguesIds' => [
                
        ],
        'name' => '',
        'numberOfProjects' => 0,
        'numberOfQuotes' => 0,
        'positionId' => 0
    ]
  ],
  'responsiblePersons' => [
    'accountManagerId' => 0,
    'projectCoordinatorId' => 0,
    'projectManagerId' => 0,
    'salesPersonId' => 0
  ],
  'salesNotes' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/customers');
$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}}/customers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountOnCustomerServer": "",
  "accounting": {
    "taxNumbers": [
      {
        "number": "",
        "type": ""
      }
    ]
  },
  "billingAddress": {
    "addressLine1": "",
    "addressLine2": "",
    "city": "",
    "countryId": 0,
    "postalCode": "",
    "provinceId": 0,
    "sameAsBillingAddress": false
  },
  "branchId": 0,
  "categoriesIds": [],
  "clientFirstProjectDate": "",
  "clientFirstQuoteDate": "",
  "clientLastProjectDate": "",
  "clientLastQuoteDate": "",
  "clientNumberOfProjects": 0,
  "clientNumberOfQuotes": 0,
  "contact": {
    "emails": {
      "additional": [],
      "cc": [],
      "primary": ""
    },
    "fax": "",
    "phones": [],
    "sms": "",
    "websites": []
  },
  "contractNumber": "",
  "correspondenceAddress": {},
  "customFields": [
    {
      "key": "",
      "name": "",
      "type": "",
      "value": {}
    }
  ],
  "fullName": "",
  "id": 0,
  "idNumber": "",
  "industriesIds": [],
  "leadSourceId": 0,
  "limitAccessToPeopleResponsible": false,
  "name": "",
  "notes": "",
  "persons": [
    {
      "active": false,
      "contact": {
        "emails": {
          "additional": [],
          "primary": ""
        },
        "fax": "",
        "phones": [],
        "sms": ""
      },
      "customFields": [
        {}
      ],
      "customerId": 0,
      "firstProjectDate": "",
      "firstQuoteDate": "",
      "gender": "",
      "id": 0,
      "lastName": "",
      "lastProjectDate": "",
      "lastQuoteDate": "",
      "motherTonguesIds": [],
      "name": "",
      "numberOfProjects": 0,
      "numberOfQuotes": 0,
      "positionId": 0
    }
  ],
  "responsiblePersons": {
    "accountManagerId": 0,
    "projectCoordinatorId": 0,
    "projectManagerId": 0,
    "salesPersonId": 0
  },
  "salesNotes": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountOnCustomerServer": "",
  "accounting": {
    "taxNumbers": [
      {
        "number": "",
        "type": ""
      }
    ]
  },
  "billingAddress": {
    "addressLine1": "",
    "addressLine2": "",
    "city": "",
    "countryId": 0,
    "postalCode": "",
    "provinceId": 0,
    "sameAsBillingAddress": false
  },
  "branchId": 0,
  "categoriesIds": [],
  "clientFirstProjectDate": "",
  "clientFirstQuoteDate": "",
  "clientLastProjectDate": "",
  "clientLastQuoteDate": "",
  "clientNumberOfProjects": 0,
  "clientNumberOfQuotes": 0,
  "contact": {
    "emails": {
      "additional": [],
      "cc": [],
      "primary": ""
    },
    "fax": "",
    "phones": [],
    "sms": "",
    "websites": []
  },
  "contractNumber": "",
  "correspondenceAddress": {},
  "customFields": [
    {
      "key": "",
      "name": "",
      "type": "",
      "value": {}
    }
  ],
  "fullName": "",
  "id": 0,
  "idNumber": "",
  "industriesIds": [],
  "leadSourceId": 0,
  "limitAccessToPeopleResponsible": false,
  "name": "",
  "notes": "",
  "persons": [
    {
      "active": false,
      "contact": {
        "emails": {
          "additional": [],
          "primary": ""
        },
        "fax": "",
        "phones": [],
        "sms": ""
      },
      "customFields": [
        {}
      ],
      "customerId": 0,
      "firstProjectDate": "",
      "firstQuoteDate": "",
      "gender": "",
      "id": 0,
      "lastName": "",
      "lastProjectDate": "",
      "lastQuoteDate": "",
      "motherTonguesIds": [],
      "name": "",
      "numberOfProjects": 0,
      "numberOfQuotes": 0,
      "positionId": 0
    }
  ],
  "responsiblePersons": {
    "accountManagerId": 0,
    "projectCoordinatorId": 0,
    "projectManagerId": 0,
    "salesPersonId": 0
  },
  "salesNotes": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/customers", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers"

payload = {
    "accountOnCustomerServer": "",
    "accounting": { "taxNumbers": [
            {
                "number": "",
                "type": ""
            }
        ] },
    "billingAddress": {
        "addressLine1": "",
        "addressLine2": "",
        "city": "",
        "countryId": 0,
        "postalCode": "",
        "provinceId": 0,
        "sameAsBillingAddress": False
    },
    "branchId": 0,
    "categoriesIds": [],
    "clientFirstProjectDate": "",
    "clientFirstQuoteDate": "",
    "clientLastProjectDate": "",
    "clientLastQuoteDate": "",
    "clientNumberOfProjects": 0,
    "clientNumberOfQuotes": 0,
    "contact": {
        "emails": {
            "additional": [],
            "cc": [],
            "primary": ""
        },
        "fax": "",
        "phones": [],
        "sms": "",
        "websites": []
    },
    "contractNumber": "",
    "correspondenceAddress": {},
    "customFields": [
        {
            "key": "",
            "name": "",
            "type": "",
            "value": {}
        }
    ],
    "fullName": "",
    "id": 0,
    "idNumber": "",
    "industriesIds": [],
    "leadSourceId": 0,
    "limitAccessToPeopleResponsible": False,
    "name": "",
    "notes": "",
    "persons": [
        {
            "active": False,
            "contact": {
                "emails": {
                    "additional": [],
                    "primary": ""
                },
                "fax": "",
                "phones": [],
                "sms": ""
            },
            "customFields": [{}],
            "customerId": 0,
            "firstProjectDate": "",
            "firstQuoteDate": "",
            "gender": "",
            "id": 0,
            "lastName": "",
            "lastProjectDate": "",
            "lastQuoteDate": "",
            "motherTonguesIds": [],
            "name": "",
            "numberOfProjects": 0,
            "numberOfQuotes": 0,
            "positionId": 0
        }
    ],
    "responsiblePersons": {
        "accountManagerId": 0,
        "projectCoordinatorId": 0,
        "projectManagerId": 0,
        "salesPersonId": 0
    },
    "salesNotes": "",
    "status": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers"

payload <- "{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\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}}/customers")

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  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\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/customers') do |req|
  req.body = "{\n  \"accountOnCustomerServer\": \"\",\n  \"accounting\": {\n    \"taxNumbers\": [\n      {\n        \"number\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"billingAddress\": {\n    \"addressLine1\": \"\",\n    \"addressLine2\": \"\",\n    \"city\": \"\",\n    \"countryId\": 0,\n    \"postalCode\": \"\",\n    \"provinceId\": 0,\n    \"sameAsBillingAddress\": false\n  },\n  \"branchId\": 0,\n  \"categoriesIds\": [],\n  \"clientFirstProjectDate\": \"\",\n  \"clientFirstQuoteDate\": \"\",\n  \"clientLastProjectDate\": \"\",\n  \"clientLastQuoteDate\": \"\",\n  \"clientNumberOfProjects\": 0,\n  \"clientNumberOfQuotes\": 0,\n  \"contact\": {\n    \"emails\": {\n      \"additional\": [],\n      \"cc\": [],\n      \"primary\": \"\"\n    },\n    \"fax\": \"\",\n    \"phones\": [],\n    \"sms\": \"\",\n    \"websites\": []\n  },\n  \"contractNumber\": \"\",\n  \"correspondenceAddress\": {},\n  \"customFields\": [\n    {\n      \"key\": \"\",\n      \"name\": \"\",\n      \"type\": \"\",\n      \"value\": {}\n    }\n  ],\n  \"fullName\": \"\",\n  \"id\": 0,\n  \"idNumber\": \"\",\n  \"industriesIds\": [],\n  \"leadSourceId\": 0,\n  \"limitAccessToPeopleResponsible\": false,\n  \"name\": \"\",\n  \"notes\": \"\",\n  \"persons\": [\n    {\n      \"active\": false,\n      \"contact\": {\n        \"emails\": {\n          \"additional\": [],\n          \"primary\": \"\"\n        },\n        \"fax\": \"\",\n        \"phones\": [],\n        \"sms\": \"\"\n      },\n      \"customFields\": [\n        {}\n      ],\n      \"customerId\": 0,\n      \"firstProjectDate\": \"\",\n      \"firstQuoteDate\": \"\",\n      \"gender\": \"\",\n      \"id\": 0,\n      \"lastName\": \"\",\n      \"lastProjectDate\": \"\",\n      \"lastQuoteDate\": \"\",\n      \"motherTonguesIds\": [],\n      \"name\": \"\",\n      \"numberOfProjects\": 0,\n      \"numberOfQuotes\": 0,\n      \"positionId\": 0\n    }\n  ],\n  \"responsiblePersons\": {\n    \"accountManagerId\": 0,\n    \"projectCoordinatorId\": 0,\n    \"projectManagerId\": 0,\n    \"salesPersonId\": 0\n  },\n  \"salesNotes\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers";

    let payload = json!({
        "accountOnCustomerServer": "",
        "accounting": json!({"taxNumbers": (
                json!({
                    "number": "",
                    "type": ""
                })
            )}),
        "billingAddress": json!({
            "addressLine1": "",
            "addressLine2": "",
            "city": "",
            "countryId": 0,
            "postalCode": "",
            "provinceId": 0,
            "sameAsBillingAddress": false
        }),
        "branchId": 0,
        "categoriesIds": (),
        "clientFirstProjectDate": "",
        "clientFirstQuoteDate": "",
        "clientLastProjectDate": "",
        "clientLastQuoteDate": "",
        "clientNumberOfProjects": 0,
        "clientNumberOfQuotes": 0,
        "contact": json!({
            "emails": json!({
                "additional": (),
                "cc": (),
                "primary": ""
            }),
            "fax": "",
            "phones": (),
            "sms": "",
            "websites": ()
        }),
        "contractNumber": "",
        "correspondenceAddress": json!({}),
        "customFields": (
            json!({
                "key": "",
                "name": "",
                "type": "",
                "value": json!({})
            })
        ),
        "fullName": "",
        "id": 0,
        "idNumber": "",
        "industriesIds": (),
        "leadSourceId": 0,
        "limitAccessToPeopleResponsible": false,
        "name": "",
        "notes": "",
        "persons": (
            json!({
                "active": false,
                "contact": json!({
                    "emails": json!({
                        "additional": (),
                        "primary": ""
                    }),
                    "fax": "",
                    "phones": (),
                    "sms": ""
                }),
                "customFields": (json!({})),
                "customerId": 0,
                "firstProjectDate": "",
                "firstQuoteDate": "",
                "gender": "",
                "id": 0,
                "lastName": "",
                "lastProjectDate": "",
                "lastQuoteDate": "",
                "motherTonguesIds": (),
                "name": "",
                "numberOfProjects": 0,
                "numberOfQuotes": 0,
                "positionId": 0
            })
        ),
        "responsiblePersons": json!({
            "accountManagerId": 0,
            "projectCoordinatorId": 0,
            "projectManagerId": 0,
            "salesPersonId": 0
        }),
        "salesNotes": "",
        "status": ""
    });

    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 '{
  "accountOnCustomerServer": "",
  "accounting": {
    "taxNumbers": [
      {
        "number": "",
        "type": ""
      }
    ]
  },
  "billingAddress": {
    "addressLine1": "",
    "addressLine2": "",
    "city": "",
    "countryId": 0,
    "postalCode": "",
    "provinceId": 0,
    "sameAsBillingAddress": false
  },
  "branchId": 0,
  "categoriesIds": [],
  "clientFirstProjectDate": "",
  "clientFirstQuoteDate": "",
  "clientLastProjectDate": "",
  "clientLastQuoteDate": "",
  "clientNumberOfProjects": 0,
  "clientNumberOfQuotes": 0,
  "contact": {
    "emails": {
      "additional": [],
      "cc": [],
      "primary": ""
    },
    "fax": "",
    "phones": [],
    "sms": "",
    "websites": []
  },
  "contractNumber": "",
  "correspondenceAddress": {},
  "customFields": [
    {
      "key": "",
      "name": "",
      "type": "",
      "value": {}
    }
  ],
  "fullName": "",
  "id": 0,
  "idNumber": "",
  "industriesIds": [],
  "leadSourceId": 0,
  "limitAccessToPeopleResponsible": false,
  "name": "",
  "notes": "",
  "persons": [
    {
      "active": false,
      "contact": {
        "emails": {
          "additional": [],
          "primary": ""
        },
        "fax": "",
        "phones": [],
        "sms": ""
      },
      "customFields": [
        {}
      ],
      "customerId": 0,
      "firstProjectDate": "",
      "firstQuoteDate": "",
      "gender": "",
      "id": 0,
      "lastName": "",
      "lastProjectDate": "",
      "lastQuoteDate": "",
      "motherTonguesIds": [],
      "name": "",
      "numberOfProjects": 0,
      "numberOfQuotes": 0,
      "positionId": 0
    }
  ],
  "responsiblePersons": {
    "accountManagerId": 0,
    "projectCoordinatorId": 0,
    "projectManagerId": 0,
    "salesPersonId": 0
  },
  "salesNotes": "",
  "status": ""
}' |  \
  http POST {{baseUrl}}/customers \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountOnCustomerServer": "",\n  "accounting": {\n    "taxNumbers": [\n      {\n        "number": "",\n        "type": ""\n      }\n    ]\n  },\n  "billingAddress": {\n    "addressLine1": "",\n    "addressLine2": "",\n    "city": "",\n    "countryId": 0,\n    "postalCode": "",\n    "provinceId": 0,\n    "sameAsBillingAddress": false\n  },\n  "branchId": 0,\n  "categoriesIds": [],\n  "clientFirstProjectDate": "",\n  "clientFirstQuoteDate": "",\n  "clientLastProjectDate": "",\n  "clientLastQuoteDate": "",\n  "clientNumberOfProjects": 0,\n  "clientNumberOfQuotes": 0,\n  "contact": {\n    "emails": {\n      "additional": [],\n      "cc": [],\n      "primary": ""\n    },\n    "fax": "",\n    "phones": [],\n    "sms": "",\n    "websites": []\n  },\n  "contractNumber": "",\n  "correspondenceAddress": {},\n  "customFields": [\n    {\n      "key": "",\n      "name": "",\n      "type": "",\n      "value": {}\n    }\n  ],\n  "fullName": "",\n  "id": 0,\n  "idNumber": "",\n  "industriesIds": [],\n  "leadSourceId": 0,\n  "limitAccessToPeopleResponsible": false,\n  "name": "",\n  "notes": "",\n  "persons": [\n    {\n      "active": false,\n      "contact": {\n        "emails": {\n          "additional": [],\n          "primary": ""\n        },\n        "fax": "",\n        "phones": [],\n        "sms": ""\n      },\n      "customFields": [\n        {}\n      ],\n      "customerId": 0,\n      "firstProjectDate": "",\n      "firstQuoteDate": "",\n      "gender": "",\n      "id": 0,\n      "lastName": "",\n      "lastProjectDate": "",\n      "lastQuoteDate": "",\n      "motherTonguesIds": [],\n      "name": "",\n      "numberOfProjects": 0,\n      "numberOfQuotes": 0,\n      "positionId": 0\n    }\n  ],\n  "responsiblePersons": {\n    "accountManagerId": 0,\n    "projectCoordinatorId": 0,\n    "projectManagerId": 0,\n    "salesPersonId": 0\n  },\n  "salesNotes": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/customers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "accountOnCustomerServer": "",
  "accounting": ["taxNumbers": [
      [
        "number": "",
        "type": ""
      ]
    ]],
  "billingAddress": [
    "addressLine1": "",
    "addressLine2": "",
    "city": "",
    "countryId": 0,
    "postalCode": "",
    "provinceId": 0,
    "sameAsBillingAddress": false
  ],
  "branchId": 0,
  "categoriesIds": [],
  "clientFirstProjectDate": "",
  "clientFirstQuoteDate": "",
  "clientLastProjectDate": "",
  "clientLastQuoteDate": "",
  "clientNumberOfProjects": 0,
  "clientNumberOfQuotes": 0,
  "contact": [
    "emails": [
      "additional": [],
      "cc": [],
      "primary": ""
    ],
    "fax": "",
    "phones": [],
    "sms": "",
    "websites": []
  ],
  "contractNumber": "",
  "correspondenceAddress": [],
  "customFields": [
    [
      "key": "",
      "name": "",
      "type": "",
      "value": []
    ]
  ],
  "fullName": "",
  "id": 0,
  "idNumber": "",
  "industriesIds": [],
  "leadSourceId": 0,
  "limitAccessToPeopleResponsible": false,
  "name": "",
  "notes": "",
  "persons": [
    [
      "active": false,
      "contact": [
        "emails": [
          "additional": [],
          "primary": ""
        ],
        "fax": "",
        "phones": [],
        "sms": ""
      ],
      "customFields": [[]],
      "customerId": 0,
      "firstProjectDate": "",
      "firstQuoteDate": "",
      "gender": "",
      "id": 0,
      "lastName": "",
      "lastProjectDate": "",
      "lastQuoteDate": "",
      "motherTonguesIds": [],
      "name": "",
      "numberOfProjects": 0,
      "numberOfQuotes": 0,
      "positionId": 0
    ]
  ],
  "responsiblePersons": [
    "accountManagerId": 0,
    "projectCoordinatorId": 0,
    "projectManagerId": 0,
    "salesPersonId": 0
  ],
  "salesNotes": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers")! 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}}/customers/persons");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/customers/persons")

require "http/client"

url = "{{baseUrl}}/customers/persons"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/customers/persons"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/persons");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/persons"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/customers/persons HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/customers/persons")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/persons"))
    .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}}/customers/persons")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/customers/persons")
  .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}}/customers/persons');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/customers/persons'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/persons';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers/persons',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/persons")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/persons',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/customers/persons'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/customers/persons');

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}}/customers/persons'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/persons';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers/persons"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers/persons" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/persons",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/customers/persons');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/persons');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/persons');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/persons' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/persons' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/customers/persons")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/persons"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/persons"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/persons")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/customers/persons') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/persons";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/customers/persons

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/customers/persons

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/persons")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/persons/accessToken");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/customers/persons/accessToken")

require "http/client"

url = "{{baseUrl}}/customers/persons/accessToken"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/customers/persons/accessToken"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/persons/accessToken");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/persons/accessToken"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/customers/persons/accessToken HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/customers/persons/accessToken")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/persons/accessToken"))
    .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}}/customers/persons/accessToken")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/customers/persons/accessToken")
  .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}}/customers/persons/accessToken');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers/persons/accessToken'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/persons/accessToken';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers/persons/accessToken',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/persons/accessToken")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/persons/accessToken',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers/persons/accessToken'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/customers/persons/accessToken');

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}}/customers/persons/accessToken'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/persons/accessToken';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers/persons/accessToken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers/persons/accessToken" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/persons/accessToken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/customers/persons/accessToken');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/persons/accessToken');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/persons/accessToken');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/persons/accessToken' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/persons/accessToken' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/customers/persons/accessToken")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/persons/accessToken"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/persons/accessToken"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/persons/accessToken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/customers/persons/accessToken') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/persons/accessToken";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/customers/persons/accessToken

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/customers/persons/accessToken

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/persons/accessToken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/:customerId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/customers/:customerId")

require "http/client"

url = "{{baseUrl}}/customers/:customerId"

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}}/customers/:customerId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:customerId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:customerId"

	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/customers/:customerId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/customers/:customerId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:customerId"))
    .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}}/customers/:customerId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/customers/:customerId")
  .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}}/customers/:customerId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/customers/:customerId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:customerId';
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}}/customers/:customerId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:customerId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:customerId',
  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}}/customers/:customerId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/customers/:customerId');

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}}/customers/:customerId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:customerId';
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}}/customers/:customerId"]
                                                       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}}/customers/:customerId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:customerId",
  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}}/customers/:customerId');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:customerId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:customerId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:customerId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:customerId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/customers/:customerId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:customerId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:customerId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:customerId")

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/customers/:customerId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:customerId";

    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}}/customers/:customerId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/customers/:customerId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:customerId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/priceLists/:priceListId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/customers/priceLists/:priceListId")

require "http/client"

url = "{{baseUrl}}/customers/priceLists/:priceListId"

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}}/customers/priceLists/:priceListId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/priceLists/:priceListId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/priceLists/:priceListId"

	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/customers/priceLists/:priceListId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/customers/priceLists/:priceListId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/priceLists/:priceListId"))
    .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}}/customers/priceLists/:priceListId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/customers/priceLists/:priceListId")
  .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}}/customers/priceLists/:priceListId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/customers/priceLists/:priceListId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/priceLists/:priceListId';
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}}/customers/priceLists/:priceListId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/priceLists/:priceListId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/priceLists/:priceListId',
  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}}/customers/priceLists/:priceListId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/customers/priceLists/:priceListId');

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}}/customers/priceLists/:priceListId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/priceLists/:priceListId';
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}}/customers/priceLists/:priceListId"]
                                                       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}}/customers/priceLists/:priceListId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/priceLists/:priceListId",
  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}}/customers/priceLists/:priceListId');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/priceLists/:priceListId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/priceLists/:priceListId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/priceLists/:priceListId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/priceLists/:priceListId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/customers/priceLists/:priceListId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/priceLists/:priceListId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/priceLists/:priceListId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/priceLists/:priceListId")

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/customers/priceLists/:priceListId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/priceLists/:priceListId";

    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}}/customers/priceLists/:priceListId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/customers/priceLists/:priceListId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/priceLists/:priceListId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/persons/:personId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/customers/persons/:personId")

require "http/client"

url = "{{baseUrl}}/customers/persons/:personId"

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}}/customers/persons/:personId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/persons/:personId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/persons/:personId"

	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/customers/persons/:personId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/customers/persons/:personId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/persons/:personId"))
    .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}}/customers/persons/:personId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/customers/persons/:personId")
  .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}}/customers/persons/:personId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/customers/persons/:personId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/persons/:personId';
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}}/customers/persons/:personId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/persons/:personId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/persons/:personId',
  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}}/customers/persons/:personId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/customers/persons/:personId');

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}}/customers/persons/:personId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/persons/:personId';
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}}/customers/persons/:personId"]
                                                       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}}/customers/persons/:personId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/persons/:personId",
  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}}/customers/persons/:personId');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/persons/:personId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/persons/:personId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/persons/:personId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/persons/:personId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/customers/persons/:personId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/persons/:personId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/persons/:personId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/persons/:personId")

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/customers/persons/:personId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/persons/:personId";

    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}}/customers/persons/:personId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/customers/persons/:personId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/persons/:personId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/:customerId/address");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/customers/:customerId/address")

require "http/client"

url = "{{baseUrl}}/customers/:customerId/address"

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}}/customers/:customerId/address"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:customerId/address");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:customerId/address"

	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/customers/:customerId/address HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/customers/:customerId/address")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:customerId/address"))
    .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}}/customers/:customerId/address")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/customers/:customerId/address")
  .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}}/customers/:customerId/address');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/customers/:customerId/address'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:customerId/address';
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}}/customers/:customerId/address',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:customerId/address")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:customerId/address',
  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}}/customers/:customerId/address'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/customers/:customerId/address');

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}}/customers/:customerId/address'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:customerId/address';
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}}/customers/:customerId/address"]
                                                       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}}/customers/:customerId/address" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:customerId/address",
  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}}/customers/:customerId/address');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:customerId/address');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:customerId/address');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:customerId/address' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:customerId/address' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/customers/:customerId/address")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:customerId/address"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:customerId/address"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:customerId/address")

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/customers/:customerId/address') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:customerId/address";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/customers/:customerId/address

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/customers/:customerId/address

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:customerId/address")! 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}}/customers/:customerId/categories");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/customers/:customerId/categories")

require "http/client"

url = "{{baseUrl}}/customers/:customerId/categories"

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}}/customers/:customerId/categories"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:customerId/categories");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:customerId/categories"

	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/customers/:customerId/categories HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/customers/:customerId/categories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:customerId/categories"))
    .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}}/customers/:customerId/categories")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/customers/:customerId/categories")
  .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}}/customers/:customerId/categories');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/customers/:customerId/categories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:customerId/categories';
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}}/customers/:customerId/categories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:customerId/categories")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:customerId/categories',
  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}}/customers/:customerId/categories'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/customers/:customerId/categories');

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}}/customers/:customerId/categories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:customerId/categories';
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}}/customers/:customerId/categories"]
                                                       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}}/customers/:customerId/categories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:customerId/categories",
  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}}/customers/:customerId/categories');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:customerId/categories');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:customerId/categories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:customerId/categories' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:customerId/categories' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/customers/:customerId/categories")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:customerId/categories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:customerId/categories"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:customerId/categories")

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/customers/:customerId/categories') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:customerId/categories";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/customers/:customerId/categories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/customers/:customerId/categories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:customerId/categories")! 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}}/customers/:customerId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/customers/:customerId")

require "http/client"

url = "{{baseUrl}}/customers/:customerId"

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}}/customers/:customerId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:customerId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:customerId"

	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/customers/:customerId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/customers/:customerId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:customerId"))
    .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}}/customers/:customerId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/customers/:customerId")
  .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}}/customers/:customerId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/customers/:customerId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:customerId';
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}}/customers/:customerId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:customerId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:customerId',
  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}}/customers/:customerId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/customers/:customerId');

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}}/customers/:customerId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:customerId';
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}}/customers/:customerId"]
                                                       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}}/customers/:customerId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:customerId",
  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}}/customers/:customerId');

echo $response->getBody();