CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/booking/availability/dates");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/booking/availability/dates" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/booking/availability/dates"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/booking/availability/dates"),
    Headers =
    {
        { "accept-language", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/booking/availability/dates");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/availability/dates"

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/booking/availability/dates HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/booking/availability/dates")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/availability/dates"))
    .header("accept-language", "")
    .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}}/booking/availability/dates")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/booking/availability/dates")
  .header("accept-language", "")
  .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}}/booking/availability/dates');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/booking/availability/dates',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/booking/availability/dates';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/booking/availability/dates',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/booking/availability/dates")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/booking/availability/dates',
  headers: {
    'accept-language': ''
  }
};

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}}/booking/availability/dates',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/booking/availability/dates');

req.headers({
  'accept-language': ''
});

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}}/booking/availability/dates',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/booking/availability/dates';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/booking/availability/dates" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/booking/availability/dates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/booking/availability/dates', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/booking/availability/dates');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept-language' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/booking/availability/dates');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/availability/dates' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/availability/dates' -Method GET -Headers $headers

import http.client

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

headers = { 'accept-language': "" }

conn.request("GET", "/baseUrl/booking/availability/dates", headers=headers)

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

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

import requests

url = "{{baseUrl}}/booking/availability/dates"

headers = {"accept-language": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/availability/dates"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/availability/dates")

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

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/booking/availability/dates') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/booking/availability/dates \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/booking/availability/dates

import Foundation

let headers = ["accept-language": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/booking/availability/tourgrades/pricingmatrix");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/booking/availability/tourgrades/pricingmatrix" {:headers {:accept-language ""}
                                                                                          :content-type :json
                                                                                          :form-params {:currencyCode ""
                                                                                                        :month ""
                                                                                                        :productCode ""
                                                                                                        :year ""}})

require "http/client"

url = "{{baseUrl}}/booking/availability/tourgrades/pricingmatrix"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\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}}/booking/availability/tourgrades/pricingmatrix"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\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}}/booking/availability/tourgrades/pricingmatrix");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/availability/tourgrades/pricingmatrix"

	payload := strings.NewReader("{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}")

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

	req.Header.Add("accept-language", "")
	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/booking/availability/tourgrades/pricingmatrix HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 74

{
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/booking/availability/tourgrades/pricingmatrix")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/availability/tourgrades/pricingmatrix"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\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  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/booking/availability/tourgrades/pricingmatrix")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/booking/availability/tourgrades/pricingmatrix")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  currencyCode: '',
  month: '',
  productCode: '',
  year: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/booking/availability/tourgrades/pricingmatrix');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/availability/tourgrades/pricingmatrix',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {currencyCode: '', month: '', productCode: '', year: ''}
};

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

const url = '{{baseUrl}}/booking/availability/tourgrades/pricingmatrix';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","month":"","productCode":"","year":""}'
};

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}}/booking/availability/tourgrades/pricingmatrix',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "currencyCode": "",\n  "month": "",\n  "productCode": "",\n  "year": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/booking/availability/tourgrades/pricingmatrix")
  .post(body)
  .addHeader("accept-language", "")
  .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/booking/availability/tourgrades/pricingmatrix',
  headers: {
    'accept-language': '',
    '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({currencyCode: '', month: '', productCode: '', year: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/availability/tourgrades/pricingmatrix',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {currencyCode: '', month: '', productCode: '', year: ''},
  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}}/booking/availability/tourgrades/pricingmatrix');

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

req.type('json');
req.send({
  currencyCode: '',
  month: '',
  productCode: '',
  year: ''
});

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}}/booking/availability/tourgrades/pricingmatrix',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {currencyCode: '', month: '', productCode: '', year: ''}
};

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

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

const url = '{{baseUrl}}/booking/availability/tourgrades/pricingmatrix';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","month":"","productCode":"","year":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"currencyCode": @"",
                              @"month": @"",
                              @"productCode": @"",
                              @"year": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/booking/availability/tourgrades/pricingmatrix"]
                                                       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}}/booking/availability/tourgrades/pricingmatrix" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}" in

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

 "{{baseUrl}}/booking/availability/tourgrades/pricingmatrix",
  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([
    'currencyCode' => '',
    'month' => '',
    'productCode' => '',
    'year' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/booking/availability/tourgrades/pricingmatrix', [
  'body' => '{
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/booking/availability/tourgrades/pricingmatrix');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'currencyCode' => '',
  'month' => '',
  'productCode' => '',
  'year' => ''
]));

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

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

append(json_encode([
  'currencyCode' => '',
  'month' => '',
  'productCode' => '',
  'year' => ''
]));
$request->setRequestUrl('{{baseUrl}}/booking/availability/tourgrades/pricingmatrix');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/availability/tourgrades/pricingmatrix' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/availability/tourgrades/pricingmatrix' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}'

import http.client

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

payload = "{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}"

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

conn.request("POST", "/baseUrl/booking/availability/tourgrades/pricingmatrix", payload, headers)

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

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

import requests

url = "{{baseUrl}}/booking/availability/tourgrades/pricingmatrix"

payload = {
    "currencyCode": "",
    "month": "",
    "productCode": "",
    "year": ""
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/availability/tourgrades/pricingmatrix"

payload <- "{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/availability/tourgrades/pricingmatrix")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\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/booking/availability/tourgrades/pricingmatrix') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "currencyCode": "",
        "month": "",
        "productCode": "",
        "year": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}' |  \
  http POST {{baseUrl}}/booking/availability/tourgrades/pricingmatrix \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "currencyCode": "",\n  "month": "",\n  "productCode": "",\n  "year": ""\n}' \
  --output-document \
  - {{baseUrl}}/booking/availability/tourgrades/pricingmatrix

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/booking/availability/tourgrades" {:headers {:accept-language ""}
                                                                            :content-type :json
                                                                            :form-params {:ageBands [{:bandId 0
                                                                                                      :count 0}]
                                                                                          :bookingDate ""
                                                                                          :currencyCode ""
                                                                                          :productCode ""}})

require "http/client"

url = "{{baseUrl}}/booking/availability/tourgrades"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\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}}/booking/availability/tourgrades"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\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}}/booking/availability/tourgrades");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/availability/tourgrades"

	payload := strings.NewReader("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}")

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

	req.Header.Add("accept-language", "")
	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/booking/availability/tourgrades HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 135

{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "bookingDate": "",
  "currencyCode": "",
  "productCode": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/booking/availability/tourgrades")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/availability/tourgrades"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\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  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/booking/availability/tourgrades")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/booking/availability/tourgrades")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ageBands: [
    {
      bandId: 0,
      count: 0
    }
  ],
  bookingDate: '',
  currencyCode: '',
  productCode: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/booking/availability/tourgrades');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/availability/tourgrades',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    ageBands: [{bandId: 0, count: 0}],
    bookingDate: '',
    currencyCode: '',
    productCode: ''
  }
};

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

const url = '{{baseUrl}}/booking/availability/tourgrades';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"ageBands":[{"bandId":0,"count":0}],"bookingDate":"","currencyCode":"","productCode":""}'
};

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}}/booking/availability/tourgrades',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ageBands": [\n    {\n      "bandId": 0,\n      "count": 0\n    }\n  ],\n  "bookingDate": "",\n  "currencyCode": "",\n  "productCode": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/booking/availability/tourgrades")
  .post(body)
  .addHeader("accept-language", "")
  .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/booking/availability/tourgrades',
  headers: {
    'accept-language': '',
    '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({
  ageBands: [{bandId: 0, count: 0}],
  bookingDate: '',
  currencyCode: '',
  productCode: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/availability/tourgrades',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {
    ageBands: [{bandId: 0, count: 0}],
    bookingDate: '',
    currencyCode: '',
    productCode: ''
  },
  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}}/booking/availability/tourgrades');

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

req.type('json');
req.send({
  ageBands: [
    {
      bandId: 0,
      count: 0
    }
  ],
  bookingDate: '',
  currencyCode: '',
  productCode: ''
});

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}}/booking/availability/tourgrades',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    ageBands: [{bandId: 0, count: 0}],
    bookingDate: '',
    currencyCode: '',
    productCode: ''
  }
};

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

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

const url = '{{baseUrl}}/booking/availability/tourgrades';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"ageBands":[{"bandId":0,"count":0}],"bookingDate":"","currencyCode":"","productCode":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ageBands": @[ @{ @"bandId": @0, @"count": @0 } ],
                              @"bookingDate": @"",
                              @"currencyCode": @"",
                              @"productCode": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/booking/availability/tourgrades"]
                                                       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}}/booking/availability/tourgrades" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}" in

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

 "{{baseUrl}}/booking/availability/tourgrades",
  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([
    'ageBands' => [
        [
                'bandId' => 0,
                'count' => 0
        ]
    ],
    'bookingDate' => '',
    'currencyCode' => '',
    'productCode' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/booking/availability/tourgrades', [
  'body' => '{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "bookingDate": "",
  "currencyCode": "",
  "productCode": ""
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/booking/availability/tourgrades');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ageBands' => [
    [
        'bandId' => 0,
        'count' => 0
    ]
  ],
  'bookingDate' => '',
  'currencyCode' => '',
  'productCode' => ''
]));

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

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

append(json_encode([
  'ageBands' => [
    [
        'bandId' => 0,
        'count' => 0
    ]
  ],
  'bookingDate' => '',
  'currencyCode' => '',
  'productCode' => ''
]));
$request->setRequestUrl('{{baseUrl}}/booking/availability/tourgrades');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/availability/tourgrades' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "bookingDate": "",
  "currencyCode": "",
  "productCode": ""
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/availability/tourgrades' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "bookingDate": "",
  "currencyCode": "",
  "productCode": ""
}'

import http.client

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

payload = "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}"

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

conn.request("POST", "/baseUrl/booking/availability/tourgrades", payload, headers)

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

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

import requests

url = "{{baseUrl}}/booking/availability/tourgrades"

payload = {
    "ageBands": [
        {
            "bandId": 0,
            "count": 0
        }
    ],
    "bookingDate": "",
    "currencyCode": "",
    "productCode": ""
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/availability/tourgrades"

payload <- "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/availability/tourgrades")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\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/booking/availability/tourgrades') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ageBands": (
            json!({
                "bandId": 0,
                "count": 0
            })
        ),
        "bookingDate": "",
        "currencyCode": "",
        "productCode": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "bookingDate": "",
  "currencyCode": "",
  "productCode": ""
}' |  \
  http POST {{baseUrl}}/booking/availability/tourgrades \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ageBands": [\n    {\n      "bandId": 0,\n      "count": 0\n    }\n  ],\n  "bookingDate": "",\n  "currencyCode": "",\n  "productCode": ""\n}' \
  --output-document \
  - {{baseUrl}}/booking/availability/tourgrades

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "ageBands": [
    [
      "bandId": 0,
      "count": 0
    ]
  ],
  "bookingDate": "",
  "currencyCode": "",
  "productCode": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/booking/availability" {:headers {:accept-language ""}
                                                                 :content-type :json
                                                                 :form-params {:ageBands [{:bandId 0
                                                                                           :count 0}]
                                                                               :currencyCode ""
                                                                               :month ""
                                                                               :productCode ""
                                                                               :year ""}})

require "http/client"

url = "{{baseUrl}}/booking/availability"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\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}}/booking/availability"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\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}}/booking/availability");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/availability"

	payload := strings.NewReader("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}")

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

	req.Header.Add("accept-language", "")
	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/booking/availability HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 143

{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/booking/availability")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/availability"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\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  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/booking/availability")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/booking/availability")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ageBands: [
    {
      bandId: 0,
      count: 0
    }
  ],
  currencyCode: '',
  month: '',
  productCode: '',
  year: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/booking/availability');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/availability',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    ageBands: [{bandId: 0, count: 0}],
    currencyCode: '',
    month: '',
    productCode: '',
    year: ''
  }
};

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

const url = '{{baseUrl}}/booking/availability';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"ageBands":[{"bandId":0,"count":0}],"currencyCode":"","month":"","productCode":"","year":""}'
};

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}}/booking/availability',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ageBands": [\n    {\n      "bandId": 0,\n      "count": 0\n    }\n  ],\n  "currencyCode": "",\n  "month": "",\n  "productCode": "",\n  "year": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/booking/availability")
  .post(body)
  .addHeader("accept-language", "")
  .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/booking/availability',
  headers: {
    'accept-language': '',
    '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({
  ageBands: [{bandId: 0, count: 0}],
  currencyCode: '',
  month: '',
  productCode: '',
  year: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/availability',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {
    ageBands: [{bandId: 0, count: 0}],
    currencyCode: '',
    month: '',
    productCode: '',
    year: ''
  },
  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}}/booking/availability');

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

req.type('json');
req.send({
  ageBands: [
    {
      bandId: 0,
      count: 0
    }
  ],
  currencyCode: '',
  month: '',
  productCode: '',
  year: ''
});

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}}/booking/availability',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    ageBands: [{bandId: 0, count: 0}],
    currencyCode: '',
    month: '',
    productCode: '',
    year: ''
  }
};

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

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

const url = '{{baseUrl}}/booking/availability';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"ageBands":[{"bandId":0,"count":0}],"currencyCode":"","month":"","productCode":"","year":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ageBands": @[ @{ @"bandId": @0, @"count": @0 } ],
                              @"currencyCode": @"",
                              @"month": @"",
                              @"productCode": @"",
                              @"year": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/booking/availability"]
                                                       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}}/booking/availability" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}" in

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

 "{{baseUrl}}/booking/availability",
  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([
    'ageBands' => [
        [
                'bandId' => 0,
                'count' => 0
        ]
    ],
    'currencyCode' => '',
    'month' => '',
    'productCode' => '',
    'year' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/booking/availability', [
  'body' => '{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ageBands' => [
    [
        'bandId' => 0,
        'count' => 0
    ]
  ],
  'currencyCode' => '',
  'month' => '',
  'productCode' => '',
  'year' => ''
]));

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

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

append(json_encode([
  'ageBands' => [
    [
        'bandId' => 0,
        'count' => 0
    ]
  ],
  'currencyCode' => '',
  'month' => '',
  'productCode' => '',
  'year' => ''
]));
$request->setRequestUrl('{{baseUrl}}/booking/availability');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/availability' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/availability' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}'

import http.client

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

payload = "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/booking/availability"

payload = {
    "ageBands": [
        {
            "bandId": 0,
            "count": 0
        }
    ],
    "currencyCode": "",
    "month": "",
    "productCode": "",
    "year": ""
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/availability"

payload <- "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/availability")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\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/booking/availability') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"ageBands\": [\n    {\n      \"bandId\": 0,\n      \"count\": 0\n    }\n  ],\n  \"currencyCode\": \"\",\n  \"month\": \"\",\n  \"productCode\": \"\",\n  \"year\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ageBands": (
            json!({
                "bandId": 0,
                "count": 0
            })
        ),
        "currencyCode": "",
        "month": "",
        "productCode": "",
        "year": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "ageBands": [
    {
      "bandId": 0,
      "count": 0
    }
  ],
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
}' |  \
  http POST {{baseUrl}}/booking/availability \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ageBands": [\n    {\n      "bandId": 0,\n      "count": 0\n    }\n  ],\n  "currencyCode": "",\n  "month": "",\n  "productCode": "",\n  "year": ""\n}' \
  --output-document \
  - {{baseUrl}}/booking/availability

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "ageBands": [
    [
      "bandId": 0,
      "count": 0
    ]
  ],
  "currencyCode": "",
  "month": "",
  "productCode": "",
  "year": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/booking/book" {:headers {:accept-language ""}
                                                         :content-type :json
                                                         :form-params {:booker {:cellPhone ""
                                                                                :cellPhoneCountryCode ""
                                                                                :email ""
                                                                                :firstname ""
                                                                                :homePhone ""
                                                                                :surname ""
                                                                                :title ""}
                                                                       :currencyCode ""
                                                                       :demo false
                                                                       :items [{:bookingQuestionAnswers [{:answer ""
                                                                                                          :questionId 0}]
                                                                                :hotelId ""
                                                                                :languageOptionCode ""
                                                                                :partnerItemDetail {:distributorItemRef ""}
                                                                                :pickupPoint ""
                                                                                :productCode ""
                                                                                :specialRequirements ""
                                                                                :tourGradeCode ""
                                                                                :travelDate ""
                                                                                :travellers [{:bandId 0
                                                                                              :firstname ""
                                                                                              :leadTraveller false
                                                                                              :surname ""
                                                                                              :title ""}]}]
                                                                       :partnerDetail {:distributorRef ""}}})

require "http/client"

url = "{{baseUrl}}/booking/book"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/booking/book"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/booking/book");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/book"

	payload := strings.NewReader("{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}")

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

	req.Header.Add("accept-language", "")
	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/booking/book HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 840

{
  "booker": {
    "cellPhone": "",
    "cellPhoneCountryCode": "",
    "email": "",
    "firstname": "",
    "homePhone": "",
    "surname": "",
    "title": ""
  },
  "currencyCode": "",
  "demo": false,
  "items": [
    {
      "bookingQuestionAnswers": [
        {
          "answer": "",
          "questionId": 0
        }
      ],
      "hotelId": "",
      "languageOptionCode": "",
      "partnerItemDetail": {
        "distributorItemRef": ""
      },
      "pickupPoint": "",
      "productCode": "",
      "specialRequirements": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0,
          "firstname": "",
          "leadTraveller": false,
          "surname": "",
          "title": ""
        }
      ]
    }
  ],
  "partnerDetail": {
    "distributorRef": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/booking/book")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/book"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/booking/book")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/booking/book")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  booker: {
    cellPhone: '',
    cellPhoneCountryCode: '',
    email: '',
    firstname: '',
    homePhone: '',
    surname: '',
    title: ''
  },
  currencyCode: '',
  demo: false,
  items: [
    {
      bookingQuestionAnswers: [
        {
          answer: '',
          questionId: 0
        }
      ],
      hotelId: '',
      languageOptionCode: '',
      partnerItemDetail: {
        distributorItemRef: ''
      },
      pickupPoint: '',
      productCode: '',
      specialRequirements: '',
      tourGradeCode: '',
      travelDate: '',
      travellers: [
        {
          bandId: 0,
          firstname: '',
          leadTraveller: false,
          surname: '',
          title: ''
        }
      ]
    }
  ],
  partnerDetail: {
    distributorRef: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/booking/book');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/book',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    booker: {
      cellPhone: '',
      cellPhoneCountryCode: '',
      email: '',
      firstname: '',
      homePhone: '',
      surname: '',
      title: ''
    },
    currencyCode: '',
    demo: false,
    items: [
      {
        bookingQuestionAnswers: [{answer: '', questionId: 0}],
        hotelId: '',
        languageOptionCode: '',
        partnerItemDetail: {distributorItemRef: ''},
        pickupPoint: '',
        productCode: '',
        specialRequirements: '',
        tourGradeCode: '',
        travelDate: '',
        travellers: [{bandId: 0, firstname: '', leadTraveller: false, surname: '', title: ''}]
      }
    ],
    partnerDetail: {distributorRef: ''}
  }
};

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

const url = '{{baseUrl}}/booking/book';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"booker":{"cellPhone":"","cellPhoneCountryCode":"","email":"","firstname":"","homePhone":"","surname":"","title":""},"currencyCode":"","demo":false,"items":[{"bookingQuestionAnswers":[{"answer":"","questionId":0}],"hotelId":"","languageOptionCode":"","partnerItemDetail":{"distributorItemRef":""},"pickupPoint":"","productCode":"","specialRequirements":"","tourGradeCode":"","travelDate":"","travellers":[{"bandId":0,"firstname":"","leadTraveller":false,"surname":"","title":""}]}],"partnerDetail":{"distributorRef":""}}'
};

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}}/booking/book',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "booker": {\n    "cellPhone": "",\n    "cellPhoneCountryCode": "",\n    "email": "",\n    "firstname": "",\n    "homePhone": "",\n    "surname": "",\n    "title": ""\n  },\n  "currencyCode": "",\n  "demo": false,\n  "items": [\n    {\n      "bookingQuestionAnswers": [\n        {\n          "answer": "",\n          "questionId": 0\n        }\n      ],\n      "hotelId": "",\n      "languageOptionCode": "",\n      "partnerItemDetail": {\n        "distributorItemRef": ""\n      },\n      "pickupPoint": "",\n      "productCode": "",\n      "specialRequirements": "",\n      "tourGradeCode": "",\n      "travelDate": "",\n      "travellers": [\n        {\n          "bandId": 0,\n          "firstname": "",\n          "leadTraveller": false,\n          "surname": "",\n          "title": ""\n        }\n      ]\n    }\n  ],\n  "partnerDetail": {\n    "distributorRef": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/booking/book")
  .post(body)
  .addHeader("accept-language", "")
  .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/booking/book',
  headers: {
    'accept-language': '',
    '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({
  booker: {
    cellPhone: '',
    cellPhoneCountryCode: '',
    email: '',
    firstname: '',
    homePhone: '',
    surname: '',
    title: ''
  },
  currencyCode: '',
  demo: false,
  items: [
    {
      bookingQuestionAnswers: [{answer: '', questionId: 0}],
      hotelId: '',
      languageOptionCode: '',
      partnerItemDetail: {distributorItemRef: ''},
      pickupPoint: '',
      productCode: '',
      specialRequirements: '',
      tourGradeCode: '',
      travelDate: '',
      travellers: [{bandId: 0, firstname: '', leadTraveller: false, surname: '', title: ''}]
    }
  ],
  partnerDetail: {distributorRef: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/book',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {
    booker: {
      cellPhone: '',
      cellPhoneCountryCode: '',
      email: '',
      firstname: '',
      homePhone: '',
      surname: '',
      title: ''
    },
    currencyCode: '',
    demo: false,
    items: [
      {
        bookingQuestionAnswers: [{answer: '', questionId: 0}],
        hotelId: '',
        languageOptionCode: '',
        partnerItemDetail: {distributorItemRef: ''},
        pickupPoint: '',
        productCode: '',
        specialRequirements: '',
        tourGradeCode: '',
        travelDate: '',
        travellers: [{bandId: 0, firstname: '', leadTraveller: false, surname: '', title: ''}]
      }
    ],
    partnerDetail: {distributorRef: ''}
  },
  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}}/booking/book');

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

req.type('json');
req.send({
  booker: {
    cellPhone: '',
    cellPhoneCountryCode: '',
    email: '',
    firstname: '',
    homePhone: '',
    surname: '',
    title: ''
  },
  currencyCode: '',
  demo: false,
  items: [
    {
      bookingQuestionAnswers: [
        {
          answer: '',
          questionId: 0
        }
      ],
      hotelId: '',
      languageOptionCode: '',
      partnerItemDetail: {
        distributorItemRef: ''
      },
      pickupPoint: '',
      productCode: '',
      specialRequirements: '',
      tourGradeCode: '',
      travelDate: '',
      travellers: [
        {
          bandId: 0,
          firstname: '',
          leadTraveller: false,
          surname: '',
          title: ''
        }
      ]
    }
  ],
  partnerDetail: {
    distributorRef: ''
  }
});

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}}/booking/book',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    booker: {
      cellPhone: '',
      cellPhoneCountryCode: '',
      email: '',
      firstname: '',
      homePhone: '',
      surname: '',
      title: ''
    },
    currencyCode: '',
    demo: false,
    items: [
      {
        bookingQuestionAnswers: [{answer: '', questionId: 0}],
        hotelId: '',
        languageOptionCode: '',
        partnerItemDetail: {distributorItemRef: ''},
        pickupPoint: '',
        productCode: '',
        specialRequirements: '',
        tourGradeCode: '',
        travelDate: '',
        travellers: [{bandId: 0, firstname: '', leadTraveller: false, surname: '', title: ''}]
      }
    ],
    partnerDetail: {distributorRef: ''}
  }
};

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

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

const url = '{{baseUrl}}/booking/book';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"booker":{"cellPhone":"","cellPhoneCountryCode":"","email":"","firstname":"","homePhone":"","surname":"","title":""},"currencyCode":"","demo":false,"items":[{"bookingQuestionAnswers":[{"answer":"","questionId":0}],"hotelId":"","languageOptionCode":"","partnerItemDetail":{"distributorItemRef":""},"pickupPoint":"","productCode":"","specialRequirements":"","tourGradeCode":"","travelDate":"","travellers":[{"bandId":0,"firstname":"","leadTraveller":false,"surname":"","title":""}]}],"partnerDetail":{"distributorRef":""}}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"booker": @{ @"cellPhone": @"", @"cellPhoneCountryCode": @"", @"email": @"", @"firstname": @"", @"homePhone": @"", @"surname": @"", @"title": @"" },
                              @"currencyCode": @"",
                              @"demo": @NO,
                              @"items": @[ @{ @"bookingQuestionAnswers": @[ @{ @"answer": @"", @"questionId": @0 } ], @"hotelId": @"", @"languageOptionCode": @"", @"partnerItemDetail": @{ @"distributorItemRef": @"" }, @"pickupPoint": @"", @"productCode": @"", @"specialRequirements": @"", @"tourGradeCode": @"", @"travelDate": @"", @"travellers": @[ @{ @"bandId": @0, @"firstname": @"", @"leadTraveller": @NO, @"surname": @"", @"title": @"" } ] } ],
                              @"partnerDetail": @{ @"distributorRef": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/booking/book"]
                                                       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}}/booking/book" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/booking/book",
  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([
    'booker' => [
        'cellPhone' => '',
        'cellPhoneCountryCode' => '',
        'email' => '',
        'firstname' => '',
        'homePhone' => '',
        'surname' => '',
        'title' => ''
    ],
    'currencyCode' => '',
    'demo' => null,
    'items' => [
        [
                'bookingQuestionAnswers' => [
                                [
                                                                'answer' => '',
                                                                'questionId' => 0
                                ]
                ],
                'hotelId' => '',
                'languageOptionCode' => '',
                'partnerItemDetail' => [
                                'distributorItemRef' => ''
                ],
                'pickupPoint' => '',
                'productCode' => '',
                'specialRequirements' => '',
                'tourGradeCode' => '',
                'travelDate' => '',
                'travellers' => [
                                [
                                                                'bandId' => 0,
                                                                'firstname' => '',
                                                                'leadTraveller' => null,
                                                                'surname' => '',
                                                                'title' => ''
                                ]
                ]
        ]
    ],
    'partnerDetail' => [
        'distributorRef' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/booking/book', [
  'body' => '{
  "booker": {
    "cellPhone": "",
    "cellPhoneCountryCode": "",
    "email": "",
    "firstname": "",
    "homePhone": "",
    "surname": "",
    "title": ""
  },
  "currencyCode": "",
  "demo": false,
  "items": [
    {
      "bookingQuestionAnswers": [
        {
          "answer": "",
          "questionId": 0
        }
      ],
      "hotelId": "",
      "languageOptionCode": "",
      "partnerItemDetail": {
        "distributorItemRef": ""
      },
      "pickupPoint": "",
      "productCode": "",
      "specialRequirements": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0,
          "firstname": "",
          "leadTraveller": false,
          "surname": "",
          "title": ""
        }
      ]
    }
  ],
  "partnerDetail": {
    "distributorRef": ""
  }
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'booker' => [
    'cellPhone' => '',
    'cellPhoneCountryCode' => '',
    'email' => '',
    'firstname' => '',
    'homePhone' => '',
    'surname' => '',
    'title' => ''
  ],
  'currencyCode' => '',
  'demo' => null,
  'items' => [
    [
        'bookingQuestionAnswers' => [
                [
                                'answer' => '',
                                'questionId' => 0
                ]
        ],
        'hotelId' => '',
        'languageOptionCode' => '',
        'partnerItemDetail' => [
                'distributorItemRef' => ''
        ],
        'pickupPoint' => '',
        'productCode' => '',
        'specialRequirements' => '',
        'tourGradeCode' => '',
        'travelDate' => '',
        'travellers' => [
                [
                                'bandId' => 0,
                                'firstname' => '',
                                'leadTraveller' => null,
                                'surname' => '',
                                'title' => ''
                ]
        ]
    ]
  ],
  'partnerDetail' => [
    'distributorRef' => ''
  ]
]));

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

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

append(json_encode([
  'booker' => [
    'cellPhone' => '',
    'cellPhoneCountryCode' => '',
    'email' => '',
    'firstname' => '',
    'homePhone' => '',
    'surname' => '',
    'title' => ''
  ],
  'currencyCode' => '',
  'demo' => null,
  'items' => [
    [
        'bookingQuestionAnswers' => [
                [
                                'answer' => '',
                                'questionId' => 0
                ]
        ],
        'hotelId' => '',
        'languageOptionCode' => '',
        'partnerItemDetail' => [
                'distributorItemRef' => ''
        ],
        'pickupPoint' => '',
        'productCode' => '',
        'specialRequirements' => '',
        'tourGradeCode' => '',
        'travelDate' => '',
        'travellers' => [
                [
                                'bandId' => 0,
                                'firstname' => '',
                                'leadTraveller' => null,
                                'surname' => '',
                                'title' => ''
                ]
        ]
    ]
  ],
  'partnerDetail' => [
    'distributorRef' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/booking/book');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/book' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "booker": {
    "cellPhone": "",
    "cellPhoneCountryCode": "",
    "email": "",
    "firstname": "",
    "homePhone": "",
    "surname": "",
    "title": ""
  },
  "currencyCode": "",
  "demo": false,
  "items": [
    {
      "bookingQuestionAnswers": [
        {
          "answer": "",
          "questionId": 0
        }
      ],
      "hotelId": "",
      "languageOptionCode": "",
      "partnerItemDetail": {
        "distributorItemRef": ""
      },
      "pickupPoint": "",
      "productCode": "",
      "specialRequirements": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0,
          "firstname": "",
          "leadTraveller": false,
          "surname": "",
          "title": ""
        }
      ]
    }
  ],
  "partnerDetail": {
    "distributorRef": ""
  }
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/book' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "booker": {
    "cellPhone": "",
    "cellPhoneCountryCode": "",
    "email": "",
    "firstname": "",
    "homePhone": "",
    "surname": "",
    "title": ""
  },
  "currencyCode": "",
  "demo": false,
  "items": [
    {
      "bookingQuestionAnswers": [
        {
          "answer": "",
          "questionId": 0
        }
      ],
      "hotelId": "",
      "languageOptionCode": "",
      "partnerItemDetail": {
        "distributorItemRef": ""
      },
      "pickupPoint": "",
      "productCode": "",
      "specialRequirements": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0,
          "firstname": "",
          "leadTraveller": false,
          "surname": "",
          "title": ""
        }
      ]
    }
  ],
  "partnerDetail": {
    "distributorRef": ""
  }
}'

import http.client

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

payload = "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/booking/book"

payload = {
    "booker": {
        "cellPhone": "",
        "cellPhoneCountryCode": "",
        "email": "",
        "firstname": "",
        "homePhone": "",
        "surname": "",
        "title": ""
    },
    "currencyCode": "",
    "demo": False,
    "items": [
        {
            "bookingQuestionAnswers": [
                {
                    "answer": "",
                    "questionId": 0
                }
            ],
            "hotelId": "",
            "languageOptionCode": "",
            "partnerItemDetail": { "distributorItemRef": "" },
            "pickupPoint": "",
            "productCode": "",
            "specialRequirements": "",
            "tourGradeCode": "",
            "travelDate": "",
            "travellers": [
                {
                    "bandId": 0,
                    "firstname": "",
                    "leadTraveller": False,
                    "surname": "",
                    "title": ""
                }
            ]
        }
    ],
    "partnerDetail": { "distributorRef": "" }
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/book"

payload <- "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/book")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/booking/book') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"booker\": {\n    \"cellPhone\": \"\",\n    \"cellPhoneCountryCode\": \"\",\n    \"email\": \"\",\n    \"firstname\": \"\",\n    \"homePhone\": \"\",\n    \"surname\": \"\",\n    \"title\": \"\"\n  },\n  \"currencyCode\": \"\",\n  \"demo\": false,\n  \"items\": [\n    {\n      \"bookingQuestionAnswers\": [\n        {\n          \"answer\": \"\",\n          \"questionId\": 0\n        }\n      ],\n      \"hotelId\": \"\",\n      \"languageOptionCode\": \"\",\n      \"partnerItemDetail\": {\n        \"distributorItemRef\": \"\"\n      },\n      \"pickupPoint\": \"\",\n      \"productCode\": \"\",\n      \"specialRequirements\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0,\n          \"firstname\": \"\",\n          \"leadTraveller\": false,\n          \"surname\": \"\",\n          \"title\": \"\"\n        }\n      ]\n    }\n  ],\n  \"partnerDetail\": {\n    \"distributorRef\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "booker": json!({
            "cellPhone": "",
            "cellPhoneCountryCode": "",
            "email": "",
            "firstname": "",
            "homePhone": "",
            "surname": "",
            "title": ""
        }),
        "currencyCode": "",
        "demo": false,
        "items": (
            json!({
                "bookingQuestionAnswers": (
                    json!({
                        "answer": "",
                        "questionId": 0
                    })
                ),
                "hotelId": "",
                "languageOptionCode": "",
                "partnerItemDetail": json!({"distributorItemRef": ""}),
                "pickupPoint": "",
                "productCode": "",
                "specialRequirements": "",
                "tourGradeCode": "",
                "travelDate": "",
                "travellers": (
                    json!({
                        "bandId": 0,
                        "firstname": "",
                        "leadTraveller": false,
                        "surname": "",
                        "title": ""
                    })
                )
            })
        ),
        "partnerDetail": json!({"distributorRef": ""})
    });

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

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

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

    dbg!(results);
}

echo '{
  "booker": {
    "cellPhone": "",
    "cellPhoneCountryCode": "",
    "email": "",
    "firstname": "",
    "homePhone": "",
    "surname": "",
    "title": ""
  },
  "currencyCode": "",
  "demo": false,
  "items": [
    {
      "bookingQuestionAnswers": [
        {
          "answer": "",
          "questionId": 0
        }
      ],
      "hotelId": "",
      "languageOptionCode": "",
      "partnerItemDetail": {
        "distributorItemRef": ""
      },
      "pickupPoint": "",
      "productCode": "",
      "specialRequirements": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0,
          "firstname": "",
          "leadTraveller": false,
          "surname": "",
          "title": ""
        }
      ]
    }
  ],
  "partnerDetail": {
    "distributorRef": ""
  }
}' |  \
  http POST {{baseUrl}}/booking/book \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "booker": {\n    "cellPhone": "",\n    "cellPhoneCountryCode": "",\n    "email": "",\n    "firstname": "",\n    "homePhone": "",\n    "surname": "",\n    "title": ""\n  },\n  "currencyCode": "",\n  "demo": false,\n  "items": [\n    {\n      "bookingQuestionAnswers": [\n        {\n          "answer": "",\n          "questionId": 0\n        }\n      ],\n      "hotelId": "",\n      "languageOptionCode": "",\n      "partnerItemDetail": {\n        "distributorItemRef": ""\n      },\n      "pickupPoint": "",\n      "productCode": "",\n      "specialRequirements": "",\n      "tourGradeCode": "",\n      "travelDate": "",\n      "travellers": [\n        {\n          "bandId": 0,\n          "firstname": "",\n          "leadTraveller": false,\n          "surname": "",\n          "title": ""\n        }\n      ]\n    }\n  ],\n  "partnerDetail": {\n    "distributorRef": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/booking/book

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "booker": [
    "cellPhone": "",
    "cellPhoneCountryCode": "",
    "email": "",
    "firstname": "",
    "homePhone": "",
    "surname": "",
    "title": ""
  ],
  "currencyCode": "",
  "demo": false,
  "items": [
    [
      "bookingQuestionAnswers": [
        [
          "answer": "",
          "questionId": 0
        ]
      ],
      "hotelId": "",
      "languageOptionCode": "",
      "partnerItemDetail": ["distributorItemRef": ""],
      "pickupPoint": "",
      "productCode": "",
      "specialRequirements": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        [
          "bandId": 0,
          "firstname": "",
          "leadTraveller": false,
          "surname": "",
          "title": ""
        ]
      ]
    ]
  ],
  "partnerDetail": ["distributorRef": ""]
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/booking/calculateprice" {:headers {:accept-language ""}
                                                                   :content-type :json
                                                                   :form-params {:currencyCode ""
                                                                                 :items [{:productCode ""
                                                                                          :tourGradeCode ""
                                                                                          :travelDate ""
                                                                                          :travellers [{:bandId 0}]}]}})

require "http/client"

url = "{{baseUrl}}/booking/calculateprice"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/booking/calculateprice"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/booking/calculateprice");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/calculateprice"

	payload := strings.NewReader("{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}")

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

	req.Header.Add("accept-language", "")
	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/booking/calculateprice HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 202

{
  "currencyCode": "",
  "items": [
    {
      "productCode": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0
        }
      ]
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/booking/calculateprice")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/calculateprice"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/booking/calculateprice")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/booking/calculateprice")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  currencyCode: '',
  items: [
    {
      productCode: '',
      tourGradeCode: '',
      travelDate: '',
      travellers: [
        {
          bandId: 0
        }
      ]
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/booking/calculateprice');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/calculateprice',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    currencyCode: '',
    items: [
      {productCode: '', tourGradeCode: '', travelDate: '', travellers: [{bandId: 0}]}
    ]
  }
};

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

const url = '{{baseUrl}}/booking/calculateprice';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","items":[{"productCode":"","tourGradeCode":"","travelDate":"","travellers":[{"bandId":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}}/booking/calculateprice',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "currencyCode": "",\n  "items": [\n    {\n      "productCode": "",\n      "tourGradeCode": "",\n      "travelDate": "",\n      "travellers": [\n        {\n          "bandId": 0\n        }\n      ]\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/booking/calculateprice")
  .post(body)
  .addHeader("accept-language", "")
  .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/booking/calculateprice',
  headers: {
    'accept-language': '',
    '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({
  currencyCode: '',
  items: [
    {productCode: '', tourGradeCode: '', travelDate: '', travellers: [{bandId: 0}]}
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/calculateprice',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {
    currencyCode: '',
    items: [
      {productCode: '', tourGradeCode: '', travelDate: '', travellers: [{bandId: 0}]}
    ]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  currencyCode: '',
  items: [
    {
      productCode: '',
      tourGradeCode: '',
      travelDate: '',
      travellers: [
        {
          bandId: 0
        }
      ]
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/calculateprice',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    currencyCode: '',
    items: [
      {productCode: '', tourGradeCode: '', travelDate: '', travellers: [{bandId: 0}]}
    ]
  }
};

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

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

const url = '{{baseUrl}}/booking/calculateprice';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","items":[{"productCode":"","tourGradeCode":"","travelDate":"","travellers":[{"bandId":0}]}]}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"currencyCode": @"",
                              @"items": @[ @{ @"productCode": @"", @"tourGradeCode": @"", @"travelDate": @"", @"travellers": @[ @{ @"bandId": @0 } ] } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/booking/calculateprice"]
                                                       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}}/booking/calculateprice" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}" in

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

 "{{baseUrl}}/booking/calculateprice",
  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([
    'currencyCode' => '',
    'items' => [
        [
                'productCode' => '',
                'tourGradeCode' => '',
                'travelDate' => '',
                'travellers' => [
                                [
                                                                'bandId' => 0
                                ]
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/booking/calculateprice', [
  'body' => '{
  "currencyCode": "",
  "items": [
    {
      "productCode": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0
        }
      ]
    }
  ]
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'currencyCode' => '',
  'items' => [
    [
        'productCode' => '',
        'tourGradeCode' => '',
        'travelDate' => '',
        'travellers' => [
                [
                                'bandId' => 0
                ]
        ]
    ]
  ]
]));

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

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

append(json_encode([
  'currencyCode' => '',
  'items' => [
    [
        'productCode' => '',
        'tourGradeCode' => '',
        'travelDate' => '',
        'travellers' => [
                [
                                'bandId' => 0
                ]
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/booking/calculateprice');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/calculateprice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "items": [
    {
      "productCode": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0
        }
      ]
    }
  ]
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/calculateprice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "items": [
    {
      "productCode": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0
        }
      ]
    }
  ]
}'

import http.client

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

payload = "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/booking/calculateprice"

payload = {
    "currencyCode": "",
    "items": [
        {
            "productCode": "",
            "tourGradeCode": "",
            "travelDate": "",
            "travellers": [{ "bandId": 0 }]
        }
    ]
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/calculateprice"

payload <- "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/calculateprice")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/booking/calculateprice') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"currencyCode\": \"\",\n  \"items\": [\n    {\n      \"productCode\": \"\",\n      \"tourGradeCode\": \"\",\n      \"travelDate\": \"\",\n      \"travellers\": [\n        {\n          \"bandId\": 0\n        }\n      ]\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "currencyCode": "",
        "items": (
            json!({
                "productCode": "",
                "tourGradeCode": "",
                "travelDate": "",
                "travellers": (json!({"bandId": 0}))
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "currencyCode": "",
  "items": [
    {
      "productCode": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [
        {
          "bandId": 0
        }
      ]
    }
  ]
}' |  \
  http POST {{baseUrl}}/booking/calculateprice \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "currencyCode": "",\n  "items": [\n    {\n      "productCode": "",\n      "tourGradeCode": "",\n      "travelDate": "",\n      "travellers": [\n        {\n          "bandId": 0\n        }\n      ]\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/booking/calculateprice

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "currencyCode": "",
  "items": [
    [
      "productCode": "",
      "tourGradeCode": "",
      "travelDate": "",
      "travellers": [["bandId": 0]]
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/booking/hotels" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/booking/hotels"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/booking/hotels");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/hotels"

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/booking/hotels HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/booking/hotels")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/hotels"))
    .header("accept-language", "")
    .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}}/booking/hotels")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/booking/hotels")
  .header("accept-language", "")
  .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}}/booking/hotels');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/booking/hotels',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/booking/hotels';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/booking/hotels',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/booking/hotels")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/booking/hotels',
  headers: {
    'accept-language': ''
  }
};

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}}/booking/hotels',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'accept-language': ''
});

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}}/booking/hotels',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/booking/hotels';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/booking/hotels" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/booking/hotels",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/booking/hotels', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accept-language' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/booking/hotels');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/hotels' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/hotels' -Method GET -Headers $headers

import http.client

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

headers = { 'accept-language': "" }

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

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

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

import requests

url = "{{baseUrl}}/booking/hotels"

headers = {"accept-language": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/hotels"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/hotels")

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

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/booking/hotels') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/booking/hotels \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/booking/hotels

import Foundation

let headers = ["accept-language": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/booking/mybookings" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/booking/mybookings"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/booking/mybookings");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/mybookings"

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/booking/mybookings HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/booking/mybookings")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/mybookings"))
    .header("accept-language", "")
    .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}}/booking/mybookings")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/booking/mybookings")
  .header("accept-language", "")
  .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}}/booking/mybookings');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/booking/mybookings',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/booking/mybookings';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/booking/mybookings',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/booking/mybookings")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/booking/mybookings',
  headers: {
    'accept-language': ''
  }
};

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}}/booking/mybookings',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'accept-language': ''
});

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}}/booking/mybookings',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/booking/mybookings';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/booking/mybookings" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/booking/mybookings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/booking/mybookings', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accept-language' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/booking/mybookings');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/mybookings' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/mybookings' -Method GET -Headers $headers

import http.client

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

headers = { 'accept-language': "" }

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

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

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

import requests

url = "{{baseUrl}}/booking/mybookings"

headers = {"accept-language": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/mybookings"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/mybookings")

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

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/booking/mybookings') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/booking/mybookings \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/booking/mybookings

import Foundation

let headers = ["accept-language": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/booking/pastbooking" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/booking/pastbooking"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/booking/pastbooking");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/pastbooking"

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/booking/pastbooking HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/booking/pastbooking")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/pastbooking"))
    .header("accept-language", "")
    .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}}/booking/pastbooking")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/booking/pastbooking")
  .header("accept-language", "")
  .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}}/booking/pastbooking');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/booking/pastbooking',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/booking/pastbooking';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/booking/pastbooking',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/booking/pastbooking")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/booking/pastbooking',
  headers: {
    'accept-language': ''
  }
};

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}}/booking/pastbooking',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'accept-language': ''
});

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}}/booking/pastbooking',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/booking/pastbooking';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/booking/pastbooking" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/booking/pastbooking",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/booking/pastbooking', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accept-language' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/booking/pastbooking');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/pastbooking' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/pastbooking' -Method GET -Headers $headers

import http.client

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

headers = { 'accept-language': "" }

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

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

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

import requests

url = "{{baseUrl}}/booking/pastbooking"

headers = {"accept-language": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/pastbooking"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/pastbooking")

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

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/booking/pastbooking') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/booking/pastbooking \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/booking/pastbooking

import Foundation

let headers = ["accept-language": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/booking/pricingmatrix" {:headers {:accept-language ""}
                                                                  :content-type :json
                                                                  :form-params {:bookingDate ""
                                                                                :currencyCode ""
                                                                                :productCode ""
                                                                                :tourGradeCode ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/booking/pricingmatrix"

	payload := strings.NewReader("{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\n}")

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

	req.Header.Add("accept-language", "")
	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/booking/pricingmatrix HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 89

{
  "bookingDate": "",
  "currencyCode": "",
  "productCode": "",
  "tourGradeCode": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/booking/pricingmatrix")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/booking/pricingmatrix")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  bookingDate: '',
  currencyCode: '',
  productCode: '',
  tourGradeCode: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/booking/pricingmatrix');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/pricingmatrix',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {bookingDate: '', currencyCode: '', productCode: '', tourGradeCode: ''}
};

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

const url = '{{baseUrl}}/booking/pricingmatrix';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"bookingDate":"","currencyCode":"","productCode":"","tourGradeCode":""}'
};

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}}/booking/pricingmatrix',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "bookingDate": "",\n  "currencyCode": "",\n  "productCode": "",\n  "tourGradeCode": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/booking/pricingmatrix")
  .post(body)
  .addHeader("accept-language", "")
  .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/booking/pricingmatrix',
  headers: {
    'accept-language': '',
    '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({bookingDate: '', currencyCode: '', productCode: '', tourGradeCode: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/pricingmatrix',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {bookingDate: '', currencyCode: '', productCode: '', tourGradeCode: ''},
  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}}/booking/pricingmatrix');

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

req.type('json');
req.send({
  bookingDate: '',
  currencyCode: '',
  productCode: '',
  tourGradeCode: ''
});

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}}/booking/pricingmatrix',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {bookingDate: '', currencyCode: '', productCode: '', tourGradeCode: ''}
};

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

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

const url = '{{baseUrl}}/booking/pricingmatrix';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"bookingDate":"","currencyCode":"","productCode":"","tourGradeCode":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"bookingDate": @"",
                              @"currencyCode": @"",
                              @"productCode": @"",
                              @"tourGradeCode": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/booking/pricingmatrix"]
                                                       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}}/booking/pricingmatrix" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\n}" in

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

 "{{baseUrl}}/booking/pricingmatrix",
  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([
    'bookingDate' => '',
    'currencyCode' => '',
    'productCode' => '',
    'tourGradeCode' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/booking/pricingmatrix', [
  'body' => '{
  "bookingDate": "",
  "currencyCode": "",
  "productCode": "",
  "tourGradeCode": ""
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'bookingDate' => '',
  'currencyCode' => '',
  'productCode' => '',
  'tourGradeCode' => ''
]));

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

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

append(json_encode([
  'bookingDate' => '',
  'currencyCode' => '',
  'productCode' => '',
  'tourGradeCode' => ''
]));
$request->setRequestUrl('{{baseUrl}}/booking/pricingmatrix');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/pricingmatrix' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bookingDate": "",
  "currencyCode": "",
  "productCode": "",
  "tourGradeCode": ""
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/pricingmatrix' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bookingDate": "",
  "currencyCode": "",
  "productCode": "",
  "tourGradeCode": ""
}'

import http.client

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

payload = "{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/booking/pricingmatrix"

payload = {
    "bookingDate": "",
    "currencyCode": "",
    "productCode": "",
    "tourGradeCode": ""
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/pricingmatrix"

payload <- "{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/pricingmatrix")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\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/booking/pricingmatrix') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"bookingDate\": \"\",\n  \"currencyCode\": \"\",\n  \"productCode\": \"\",\n  \"tourGradeCode\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "bookingDate": "",
        "currencyCode": "",
        "productCode": "",
        "tourGradeCode": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "bookingDate": "",
  "currencyCode": "",
  "productCode": "",
  "tourGradeCode": ""
}' |  \
  http POST {{baseUrl}}/booking/pricingmatrix \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "bookingDate": "",\n  "currencyCode": "",\n  "productCode": "",\n  "tourGradeCode": ""\n}' \
  --output-document \
  - {{baseUrl}}/booking/pricingmatrix

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "bookingDate": "",
  "currencyCode": "",
  "productCode": "",
  "tourGradeCode": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/booking/status/items" {:headers {:accept-language ""}
                                                                 :content-type :json
                                                                 :form-params {:bookingDateFrom ""
                                                                               :bookingDateTo ""
                                                                               :distributorItemRefs []
                                                                               :distributorRefs []
                                                                               :itemIds []
                                                                               :leadFirstName ""
                                                                               :leadSurname ""
                                                                               :test false}})

require "http/client"

url = "{{baseUrl}}/booking/status/items"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\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}}/booking/status/items"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\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}}/booking/status/items");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/status/items"

	payload := strings.NewReader("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}")

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

	req.Header.Add("accept-language", "")
	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/booking/status/items HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 182

{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/booking/status/items")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/status/items"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\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  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/booking/status/items")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/booking/status/items")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}")
  .asString();

const data = JSON.stringify({
  bookingDateFrom: '',
  bookingDateTo: '',
  distributorItemRefs: [],
  distributorRefs: [],
  itemIds: [],
  leadFirstName: '',
  leadSurname: '',
  test: false
});

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

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

xhr.open('POST', '{{baseUrl}}/booking/status/items');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/status/items',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    bookingDateFrom: '',
    bookingDateTo: '',
    distributorItemRefs: [],
    distributorRefs: [],
    itemIds: [],
    leadFirstName: '',
    leadSurname: '',
    test: false
  }
};

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

const url = '{{baseUrl}}/booking/status/items';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"bookingDateFrom":"","bookingDateTo":"","distributorItemRefs":[],"distributorRefs":[],"itemIds":[],"leadFirstName":"","leadSurname":"","test":false}'
};

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}}/booking/status/items',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "bookingDateFrom": "",\n  "bookingDateTo": "",\n  "distributorItemRefs": [],\n  "distributorRefs": [],\n  "itemIds": [],\n  "leadFirstName": "",\n  "leadSurname": "",\n  "test": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/booking/status/items")
  .post(body)
  .addHeader("accept-language", "")
  .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/booking/status/items',
  headers: {
    'accept-language': '',
    '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({
  bookingDateFrom: '',
  bookingDateTo: '',
  distributorItemRefs: [],
  distributorRefs: [],
  itemIds: [],
  leadFirstName: '',
  leadSurname: '',
  test: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/status/items',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {
    bookingDateFrom: '',
    bookingDateTo: '',
    distributorItemRefs: [],
    distributorRefs: [],
    itemIds: [],
    leadFirstName: '',
    leadSurname: '',
    test: false
  },
  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}}/booking/status/items');

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

req.type('json');
req.send({
  bookingDateFrom: '',
  bookingDateTo: '',
  distributorItemRefs: [],
  distributorRefs: [],
  itemIds: [],
  leadFirstName: '',
  leadSurname: '',
  test: false
});

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}}/booking/status/items',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    bookingDateFrom: '',
    bookingDateTo: '',
    distributorItemRefs: [],
    distributorRefs: [],
    itemIds: [],
    leadFirstName: '',
    leadSurname: '',
    test: false
  }
};

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

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

const url = '{{baseUrl}}/booking/status/items';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"bookingDateFrom":"","bookingDateTo":"","distributorItemRefs":[],"distributorRefs":[],"itemIds":[],"leadFirstName":"","leadSurname":"","test":false}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"bookingDateFrom": @"",
                              @"bookingDateTo": @"",
                              @"distributorItemRefs": @[  ],
                              @"distributorRefs": @[  ],
                              @"itemIds": @[  ],
                              @"leadFirstName": @"",
                              @"leadSurname": @"",
                              @"test": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/booking/status/items"]
                                                       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}}/booking/status/items" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}" in

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

 "{{baseUrl}}/booking/status/items",
  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([
    'bookingDateFrom' => '',
    'bookingDateTo' => '',
    'distributorItemRefs' => [
        
    ],
    'distributorRefs' => [
        
    ],
    'itemIds' => [
        
    ],
    'leadFirstName' => '',
    'leadSurname' => '',
    'test' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/booking/status/items', [
  'body' => '{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/booking/status/items');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'bookingDateFrom' => '',
  'bookingDateTo' => '',
  'distributorItemRefs' => [
    
  ],
  'distributorRefs' => [
    
  ],
  'itemIds' => [
    
  ],
  'leadFirstName' => '',
  'leadSurname' => '',
  'test' => null
]));

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

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

append(json_encode([
  'bookingDateFrom' => '',
  'bookingDateTo' => '',
  'distributorItemRefs' => [
    
  ],
  'distributorRefs' => [
    
  ],
  'itemIds' => [
    
  ],
  'leadFirstName' => '',
  'leadSurname' => '',
  'test' => null
]));
$request->setRequestUrl('{{baseUrl}}/booking/status/items');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/status/items' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/status/items' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}'

import http.client

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

payload = "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}"

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

conn.request("POST", "/baseUrl/booking/status/items", payload, headers)

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

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

import requests

url = "{{baseUrl}}/booking/status/items"

payload = {
    "bookingDateFrom": "",
    "bookingDateTo": "",
    "distributorItemRefs": [],
    "distributorRefs": [],
    "itemIds": [],
    "leadFirstName": "",
    "leadSurname": "",
    "test": False
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/status/items"

payload <- "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/status/items")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\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/booking/status/items') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "bookingDateFrom": "",
        "bookingDateTo": "",
        "distributorItemRefs": (),
        "distributorRefs": (),
        "itemIds": (),
        "leadFirstName": "",
        "leadSurname": "",
        "test": false
    });

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

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

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

    dbg!(results);
}

echo '{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}' |  \
  http POST {{baseUrl}}/booking/status/items \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "bookingDateFrom": "",\n  "bookingDateTo": "",\n  "distributorItemRefs": [],\n  "distributorRefs": [],\n  "itemIds": [],\n  "leadFirstName": "",\n  "leadSurname": "",\n  "test": false\n}' \
  --output-document \
  - {{baseUrl}}/booking/status/items

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/booking/status" {:headers {:accept-language ""}
                                                           :content-type :json
                                                           :form-params {:bookingDateFrom ""
                                                                         :bookingDateTo ""
                                                                         :distributorItemRefs []
                                                                         :distributorRefs []
                                                                         :itemIds []
                                                                         :leadFirstName ""
                                                                         :leadSurname ""
                                                                         :test false}})

require "http/client"

url = "{{baseUrl}}/booking/status"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\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}}/booking/status"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\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}}/booking/status");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/status"

	payload := strings.NewReader("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}")

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

	req.Header.Add("accept-language", "")
	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/booking/status HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 182

{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/booking/status")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/status"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\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  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/booking/status")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/booking/status")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}")
  .asString();

const data = JSON.stringify({
  bookingDateFrom: '',
  bookingDateTo: '',
  distributorItemRefs: [],
  distributorRefs: [],
  itemIds: [],
  leadFirstName: '',
  leadSurname: '',
  test: false
});

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

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

xhr.open('POST', '{{baseUrl}}/booking/status');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/status',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    bookingDateFrom: '',
    bookingDateTo: '',
    distributorItemRefs: [],
    distributorRefs: [],
    itemIds: [],
    leadFirstName: '',
    leadSurname: '',
    test: false
  }
};

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

const url = '{{baseUrl}}/booking/status';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"bookingDateFrom":"","bookingDateTo":"","distributorItemRefs":[],"distributorRefs":[],"itemIds":[],"leadFirstName":"","leadSurname":"","test":false}'
};

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}}/booking/status',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "bookingDateFrom": "",\n  "bookingDateTo": "",\n  "distributorItemRefs": [],\n  "distributorRefs": [],\n  "itemIds": [],\n  "leadFirstName": "",\n  "leadSurname": "",\n  "test": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/booking/status")
  .post(body)
  .addHeader("accept-language", "")
  .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/booking/status',
  headers: {
    'accept-language': '',
    '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({
  bookingDateFrom: '',
  bookingDateTo: '',
  distributorItemRefs: [],
  distributorRefs: [],
  itemIds: [],
  leadFirstName: '',
  leadSurname: '',
  test: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/booking/status',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {
    bookingDateFrom: '',
    bookingDateTo: '',
    distributorItemRefs: [],
    distributorRefs: [],
    itemIds: [],
    leadFirstName: '',
    leadSurname: '',
    test: false
  },
  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}}/booking/status');

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

req.type('json');
req.send({
  bookingDateFrom: '',
  bookingDateTo: '',
  distributorItemRefs: [],
  distributorRefs: [],
  itemIds: [],
  leadFirstName: '',
  leadSurname: '',
  test: false
});

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}}/booking/status',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    bookingDateFrom: '',
    bookingDateTo: '',
    distributorItemRefs: [],
    distributorRefs: [],
    itemIds: [],
    leadFirstName: '',
    leadSurname: '',
    test: false
  }
};

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

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

const url = '{{baseUrl}}/booking/status';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"bookingDateFrom":"","bookingDateTo":"","distributorItemRefs":[],"distributorRefs":[],"itemIds":[],"leadFirstName":"","leadSurname":"","test":false}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"bookingDateFrom": @"",
                              @"bookingDateTo": @"",
                              @"distributorItemRefs": @[  ],
                              @"distributorRefs": @[  ],
                              @"itemIds": @[  ],
                              @"leadFirstName": @"",
                              @"leadSurname": @"",
                              @"test": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/booking/status"]
                                                       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}}/booking/status" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}" in

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

 "{{baseUrl}}/booking/status",
  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([
    'bookingDateFrom' => '',
    'bookingDateTo' => '',
    'distributorItemRefs' => [
        
    ],
    'distributorRefs' => [
        
    ],
    'itemIds' => [
        
    ],
    'leadFirstName' => '',
    'leadSurname' => '',
    'test' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/booking/status', [
  'body' => '{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'bookingDateFrom' => '',
  'bookingDateTo' => '',
  'distributorItemRefs' => [
    
  ],
  'distributorRefs' => [
    
  ],
  'itemIds' => [
    
  ],
  'leadFirstName' => '',
  'leadSurname' => '',
  'test' => null
]));

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

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

append(json_encode([
  'bookingDateFrom' => '',
  'bookingDateTo' => '',
  'distributorItemRefs' => [
    
  ],
  'distributorRefs' => [
    
  ],
  'itemIds' => [
    
  ],
  'leadFirstName' => '',
  'leadSurname' => '',
  'test' => null
]));
$request->setRequestUrl('{{baseUrl}}/booking/status');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/status' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/status' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}'

import http.client

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

payload = "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/booking/status"

payload = {
    "bookingDateFrom": "",
    "bookingDateTo": "",
    "distributorItemRefs": [],
    "distributorRefs": [],
    "itemIds": [],
    "leadFirstName": "",
    "leadSurname": "",
    "test": False
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/status"

payload <- "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/status")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\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/booking/status') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"bookingDateFrom\": \"\",\n  \"bookingDateTo\": \"\",\n  \"distributorItemRefs\": [],\n  \"distributorRefs\": [],\n  \"itemIds\": [],\n  \"leadFirstName\": \"\",\n  \"leadSurname\": \"\",\n  \"test\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "bookingDateFrom": "",
        "bookingDateTo": "",
        "distributorItemRefs": (),
        "distributorRefs": (),
        "itemIds": (),
        "leadFirstName": "",
        "leadSurname": "",
        "test": false
    });

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

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

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

    dbg!(results);
}

echo '{
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
}' |  \
  http POST {{baseUrl}}/booking/status \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "bookingDateFrom": "",\n  "bookingDateTo": "",\n  "distributorItemRefs": [],\n  "distributorRefs": [],\n  "itemIds": [],\n  "leadFirstName": "",\n  "leadSurname": "",\n  "test": false\n}' \
  --output-document \
  - {{baseUrl}}/booking/status

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "bookingDateFrom": "",
  "bookingDateTo": "",
  "distributorItemRefs": [],
  "distributorRefs": [],
  "itemIds": [],
  "leadFirstName": "",
  "leadSurname": "",
  "test": false
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/booking/voucher" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/booking/voucher"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/booking/voucher");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/booking/voucher"

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/booking/voucher HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/booking/voucher")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/booking/voucher"))
    .header("accept-language", "")
    .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}}/booking/voucher")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/booking/voucher")
  .header("accept-language", "")
  .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}}/booking/voucher');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/booking/voucher',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/booking/voucher';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/booking/voucher',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/booking/voucher")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/booking/voucher',
  headers: {
    'accept-language': ''
  }
};

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}}/booking/voucher',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'accept-language': ''
});

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}}/booking/voucher',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/booking/voucher';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/booking/voucher" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/booking/voucher",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/booking/voucher', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accept-language' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/booking/voucher');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/booking/voucher' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/booking/voucher' -Method GET -Headers $headers

import http.client

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

headers = { 'accept-language': "" }

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

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

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

import requests

url = "{{baseUrl}}/booking/voucher"

headers = {"accept-language": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/booking/voucher"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/booking/voucher")

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

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/booking/voucher') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/booking/voucher \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/booking/voucher

import Foundation

let headers = ["accept-language": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bookings/cancel-reasons");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bookings/cancel-reasons" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/bookings/cancel-reasons"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bookings/cancel-reasons"),
    Headers =
    {
        { "accept-language", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bookings/cancel-reasons");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bookings/cancel-reasons"

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/bookings/cancel-reasons HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bookings/cancel-reasons")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bookings/cancel-reasons"))
    .header("accept-language", "")
    .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}}/bookings/cancel-reasons")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/bookings/cancel-reasons")
  .header("accept-language", "")
  .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}}/bookings/cancel-reasons');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bookings/cancel-reasons',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/bookings/cancel-reasons';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/bookings/cancel-reasons',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bookings/cancel-reasons")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bookings/cancel-reasons',
  headers: {
    'accept-language': ''
  }
};

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}}/bookings/cancel-reasons',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bookings/cancel-reasons');

req.headers({
  'accept-language': ''
});

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}}/bookings/cancel-reasons',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/bookings/cancel-reasons';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/bookings/cancel-reasons" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/bookings/cancel-reasons",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/bookings/cancel-reasons', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/bookings/cancel-reasons');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept-language' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/bookings/cancel-reasons');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/bookings/cancel-reasons' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bookings/cancel-reasons' -Method GET -Headers $headers

import http.client

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

headers = { 'accept-language': "" }

conn.request("GET", "/baseUrl/bookings/cancel-reasons", headers=headers)

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

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

import requests

url = "{{baseUrl}}/bookings/cancel-reasons"

headers = {"accept-language": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/bookings/cancel-reasons"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bookings/cancel-reasons")

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

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/bookings/cancel-reasons') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/bookings/cancel-reasons \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/bookings/cancel-reasons

import Foundation

let headers = ["accept-language": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bookings/:booking-reference/cancel-quote");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bookings/:booking-reference/cancel-quote")

require "http/client"

url = "{{baseUrl}}/bookings/:booking-reference/cancel-quote"

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

var client = new RestClient("{{baseUrl}}/bookings/:booking-reference/cancel-quote");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bookings/:booking-reference/cancel-quote"

	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/bookings/:booking-reference/cancel-quote HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bookings/:booking-reference/cancel-quote")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bookings/:booking-reference/cancel-quote"))
    .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}}/bookings/:booking-reference/cancel-quote")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/bookings/:booking-reference/cancel-quote")
  .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}}/bookings/:booking-reference/cancel-quote');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bookings/:booking-reference/cancel-quote'
};

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

const url = '{{baseUrl}}/bookings/:booking-reference/cancel-quote';
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}}/bookings/:booking-reference/cancel-quote',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bookings/:booking-reference/cancel-quote")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bookings/:booking-reference/cancel-quote');

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}}/bookings/:booking-reference/cancel-quote'
};

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

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

const url = '{{baseUrl}}/bookings/:booking-reference/cancel-quote';
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}}/bookings/:booking-reference/cancel-quote"]
                                                       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}}/bookings/:booking-reference/cancel-quote" in

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

 "{{baseUrl}}/bookings/:booking-reference/cancel-quote",
  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}}/bookings/:booking-reference/cancel-quote');

echo $response->getBody();

setUrl('{{baseUrl}}/bookings/:booking-reference/cancel-quote');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/bookings/:booking-reference/cancel-quote');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bookings/:booking-reference/cancel-quote' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bookings/:booking-reference/cancel-quote' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/bookings/:booking-reference/cancel-quote")

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

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

import requests

url = "{{baseUrl}}/bookings/:booking-reference/cancel-quote"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bookings/:booking-reference/cancel-quote"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bookings/:booking-reference/cancel-quote")

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/bookings/:booking-reference/cancel-quote') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bookings/:booking-reference/cancel-quote";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/bookings/:booking-reference/cancel-quote

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bookings/:booking-reference/cancel-quote

import Foundation

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/bookings/:booking-reference/cancel" {:headers {:accept-language ""}
                                                                               :content-type :json
                                                                               :form-params {:reasonCode ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/bookings/:booking-reference/cancel"

	payload := strings.NewReader("{\n  \"reasonCode\": \"\"\n}")

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

	req.Header.Add("accept-language", "")
	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/bookings/:booking-reference/cancel HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "reasonCode": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bookings/:booking-reference/cancel")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"reasonCode\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/bookings/:booking-reference/cancel")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"reasonCode\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/bookings/:booking-reference/cancel');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bookings/:booking-reference/cancel',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {reasonCode: ''}
};

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

const url = '{{baseUrl}}/bookings/:booking-reference/cancel';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"reasonCode":""}'
};

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}}/bookings/:booking-reference/cancel',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "reasonCode": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"reasonCode\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/bookings/:booking-reference/cancel")
  .post(body)
  .addHeader("accept-language", "")
  .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/bookings/:booking-reference/cancel',
  headers: {
    'accept-language': '',
    '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({reasonCode: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bookings/:booking-reference/cancel',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {reasonCode: ''},
  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}}/bookings/:booking-reference/cancel');

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

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

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}}/bookings/:booking-reference/cancel',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {reasonCode: ''}
};

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

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

const url = '{{baseUrl}}/bookings/:booking-reference/cancel';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"reasonCode":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"reasonCode": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bookings/:booking-reference/cancel"]
                                                       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}}/bookings/:booking-reference/cancel" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"reasonCode\": \"\"\n}" in

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

 "{{baseUrl}}/bookings/:booking-reference/cancel",
  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([
    'reasonCode' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/bookings/:booking-reference/cancel', [
  'body' => '{
  "reasonCode": ""
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/bookings/:booking-reference/cancel');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'reasonCode' => ''
]));
$request->setRequestUrl('{{baseUrl}}/bookings/:booking-reference/cancel');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/bookings/:booking-reference/cancel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "reasonCode": ""
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bookings/:booking-reference/cancel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "reasonCode": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/bookings/:booking-reference/cancel", payload, headers)

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

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

import requests

url = "{{baseUrl}}/bookings/:booking-reference/cancel"

payload = { "reasonCode": "" }
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/bookings/:booking-reference/cancel"

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

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bookings/:booking-reference/cancel")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"reasonCode\": \"\"\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/bookings/:booking-reference/cancel') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"reasonCode\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bookings/:booking-reference/cancel";

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

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

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

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

    dbg!(results);
}

echo '{
  "reasonCode": ""
}' |  \
  http POST {{baseUrl}}/bookings/:booking-reference/cancel \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "reasonCode": ""\n}' \
  --output-document \
  - {{baseUrl}}/bookings/:booking-reference/cancel

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = ["reasonCode": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bookings/:booking-reference/cancel")! 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}}/merchant/cancellation");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/merchant/cancellation" {:headers {:accept-language ""}
                                                                  :content-type :json
                                                                  :form-params {:distributorRef "Jdp122"
                                                                                :itineraryId 1234655}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/merchant/cancellation"

	payload := strings.NewReader("{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\n}")

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

	req.Header.Add("accept-language", "")
	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/merchant/cancellation HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "distributorRef": "Jdp122",
  "itineraryId": 1234655
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchant/cancellation")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/merchant/cancellation")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\n}")
  .asString();

const data = JSON.stringify({
  distributorRef: 'Jdp122',
  itineraryId: 1234655
});

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

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

xhr.open('POST', '{{baseUrl}}/merchant/cancellation');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchant/cancellation',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {distributorRef: 'Jdp122', itineraryId: 1234655}
};

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

const url = '{{baseUrl}}/merchant/cancellation';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"distributorRef":"Jdp122","itineraryId":1234655}'
};

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}}/merchant/cancellation',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "distributorRef": "Jdp122",\n  "itineraryId": 1234655\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchant/cancellation")
  .post(body)
  .addHeader("accept-language", "")
  .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/merchant/cancellation',
  headers: {
    'accept-language': '',
    '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({distributorRef: 'Jdp122', itineraryId: 1234655}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchant/cancellation',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {distributorRef: 'Jdp122', itineraryId: 1234655},
  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}}/merchant/cancellation');

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

req.type('json');
req.send({
  distributorRef: 'Jdp122',
  itineraryId: 1234655
});

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}}/merchant/cancellation',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {distributorRef: 'Jdp122', itineraryId: 1234655}
};

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

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

const url = '{{baseUrl}}/merchant/cancellation';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"distributorRef":"Jdp122","itineraryId":1234655}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"distributorRef": @"Jdp122",
                              @"itineraryId": @1234655 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchant/cancellation"]
                                                       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}}/merchant/cancellation" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\n}" in

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

 "{{baseUrl}}/merchant/cancellation",
  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([
    'distributorRef' => 'Jdp122',
    'itineraryId' => 1234655
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/merchant/cancellation', [
  'body' => '{
  "distributorRef": "Jdp122",
  "itineraryId": 1234655
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'distributorRef' => 'Jdp122',
  'itineraryId' => 1234655
]));

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

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

append(json_encode([
  'distributorRef' => 'Jdp122',
  'itineraryId' => 1234655
]));
$request->setRequestUrl('{{baseUrl}}/merchant/cancellation');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchant/cancellation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "distributorRef": "Jdp122",
  "itineraryId": 1234655
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchant/cancellation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "distributorRef": "Jdp122",
  "itineraryId": 1234655
}'

import http.client

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

payload = "{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/merchant/cancellation"

payload = {
    "distributorRef": "Jdp122",
    "itineraryId": 1234655
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchant/cancellation"

payload <- "{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchant/cancellation")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\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/merchant/cancellation') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"distributorRef\": \"Jdp122\",\n  \"itineraryId\": 1234655\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "distributorRef": "Jdp122",
        "itineraryId": 1234655
    });

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

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

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

    dbg!(results);
}

echo '{
  "distributorRef": "Jdp122",
  "itineraryId": 1234655
}' |  \
  http POST {{baseUrl}}/merchant/cancellation \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "distributorRef": "Jdp122",\n  "itineraryId": 1234655\n}' \
  --output-document \
  - {{baseUrl}}/merchant/cancellation

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "distributorRef": "Jdp122",
  "itineraryId": 1234655
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/health/check" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/health/check"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/health/check");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/health/check"

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/health/check HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/health/check")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/health/check"))
    .header("accept-language", "")
    .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}}/health/check")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/health/check")
  .header("accept-language", "")
  .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}}/health/check');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/health/check',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/health/check';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/health/check',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/health/check")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/health/check',
  headers: {
    'accept-language': ''
  }
};

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}}/health/check',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'accept-language': ''
});

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}}/health/check',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/health/check';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/health/check" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/health/check",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/health/check', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accept-language' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/health/check');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/health/check' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/health/check' -Method GET -Headers $headers

import http.client

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

headers = { 'accept-language': "" }

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

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

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

import requests

url = "{{baseUrl}}/health/check"

headers = {"accept-language": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/health/check"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/health/check")

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

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/health/check') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/health/check \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/health/check

import Foundation

let headers = ["accept-language": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/available/products" {:headers {:accept-language ""}
                                                               :content-type :json
                                                               :form-params {:currencyCode ""
                                                                             :endDate ""
                                                                             :numAdults 0
                                                                             :productCodes []
                                                                             :startDate ""}})

require "http/client"

url = "{{baseUrl}}/available/products"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\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}}/available/products"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\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}}/available/products");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/available/products"

	payload := strings.NewReader("{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}")

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

	req.Header.Add("accept-language", "")
	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/available/products HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 100

{
  "currencyCode": "",
  "endDate": "",
  "numAdults": 0,
  "productCodes": [],
  "startDate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/available/products")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/available/products"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\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  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/available/products")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/available/products")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  currencyCode: '',
  endDate: '',
  numAdults: 0,
  productCodes: [],
  startDate: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/available/products');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/available/products',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {currencyCode: '', endDate: '', numAdults: 0, productCodes: [], startDate: ''}
};

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

const url = '{{baseUrl}}/available/products';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","endDate":"","numAdults":0,"productCodes":[],"startDate":""}'
};

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}}/available/products',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "currencyCode": "",\n  "endDate": "",\n  "numAdults": 0,\n  "productCodes": [],\n  "startDate": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/available/products")
  .post(body)
  .addHeader("accept-language", "")
  .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/available/products',
  headers: {
    'accept-language': '',
    '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({currencyCode: '', endDate: '', numAdults: 0, productCodes: [], startDate: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/available/products',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {currencyCode: '', endDate: '', numAdults: 0, productCodes: [], startDate: ''},
  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}}/available/products');

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

req.type('json');
req.send({
  currencyCode: '',
  endDate: '',
  numAdults: 0,
  productCodes: [],
  startDate: ''
});

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}}/available/products',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {currencyCode: '', endDate: '', numAdults: 0, productCodes: [], startDate: ''}
};

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

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

const url = '{{baseUrl}}/available/products';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","endDate":"","numAdults":0,"productCodes":[],"startDate":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"currencyCode": @"",
                              @"endDate": @"",
                              @"numAdults": @0,
                              @"productCodes": @[  ],
                              @"startDate": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/available/products"]
                                                       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}}/available/products" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}" in

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

 "{{baseUrl}}/available/products",
  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([
    'currencyCode' => '',
    'endDate' => '',
    'numAdults' => 0,
    'productCodes' => [
        
    ],
    'startDate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/available/products', [
  'body' => '{
  "currencyCode": "",
  "endDate": "",
  "numAdults": 0,
  "productCodes": [],
  "startDate": ""
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'currencyCode' => '',
  'endDate' => '',
  'numAdults' => 0,
  'productCodes' => [
    
  ],
  'startDate' => ''
]));

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

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

append(json_encode([
  'currencyCode' => '',
  'endDate' => '',
  'numAdults' => 0,
  'productCodes' => [
    
  ],
  'startDate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/available/products');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/available/products' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "endDate": "",
  "numAdults": 0,
  "productCodes": [],
  "startDate": ""
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/available/products' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "endDate": "",
  "numAdults": 0,
  "productCodes": [],
  "startDate": ""
}'

import http.client

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

payload = "{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/available/products"

payload = {
    "currencyCode": "",
    "endDate": "",
    "numAdults": 0,
    "productCodes": [],
    "startDate": ""
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/available/products"

payload <- "{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/available/products")

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

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\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/available/products') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"currencyCode\": \"\",\n  \"endDate\": \"\",\n  \"numAdults\": 0,\n  \"productCodes\": [],\n  \"startDate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "currencyCode": "",
        "endDate": "",
        "numAdults": 0,
        "productCodes": (),
        "startDate": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "currencyCode": "",
  "endDate": "",
  "numAdults": 0,
  "productCodes": [],
  "startDate": ""
}' |  \
  http POST {{baseUrl}}/available/products \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "currencyCode": "",\n  "endDate": "",\n  "numAdults": 0,\n  "productCodes": [],\n  "startDate": ""\n}' \
  --output-document \
  - {{baseUrl}}/available/products

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "currencyCode": "",
  "endDate": "",
  "numAdults": 0,
  "productCodes": [],
  "startDate": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/product/photos" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/product/photos"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/product/photos");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/product/photos"

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/product/photos HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/product/photos")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/product/photos"))
    .header("accept-language", "")
    .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}}/product/photos")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/product/photos")
  .header("accept-language", "")
  .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}}/product/photos');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/product/photos',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/product/photos';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/product/photos',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/product/photos")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/product/photos',
  headers: {
    'accept-language': ''
  }
};

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}}/product/photos',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'accept-language': ''
});

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}}/product/photos',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/product/photos';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/product/photos" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/product/photos",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/product/photos', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accept-language' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/product/photos');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/product/photos' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/product/photos' -Method GET -Headers $headers

import http.client

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

headers = { 'accept-language': "" }

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

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

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

import requests

url = "{{baseUrl}}/product/photos"

headers = {"accept-language": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/product/photos"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/product/photos")

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

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/product/photos') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/product/photos \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/product/photos

import Foundation

let headers = ["accept-language": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/product/reviews" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/product/reviews"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/product/reviews");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/product/reviews"

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/product/reviews HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/product/reviews")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/product/reviews"))
    .header("accept-language", "")
    .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}}/product/reviews")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/product/reviews")
  .header("accept-language", "")
  .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}}/product/reviews');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/product/reviews',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/product/reviews';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/product/reviews',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/product/reviews")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/product/reviews',
  headers: {
    'accept-language': ''
  }
};

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}}/product/reviews',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'accept-language': ''
});

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}}/product/reviews',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/product/reviews';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/product/reviews" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/product/reviews",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/product/reviews', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accept-language' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/product/reviews');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/product/reviews' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/product/reviews' -Method GET -Headers $headers

import http.client

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

headers = { 'accept-language': "" }

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

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

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

import requests

url = "{{baseUrl}}/product/reviews"

headers = {"accept-language": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/product/reviews"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/product/reviews")

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

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/product/reviews') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/product/reviews \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/product/reviews

import Foundation

let headers = ["accept-language": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/product" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/product"
headers = HTTP::Headers{
  "accept-language" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/product");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("accept-language", "")

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

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

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

}

GET /baseUrl/product HTTP/1.1
Accept-Language: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/product"))
    .header("accept-language", "")
    .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}}/product")
  .get()
  .addHeader("accept-language", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/product")
  .header("accept-language", "")
  .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}}/product');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/product',
  headers: {'accept-language': ''}
};

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

const url = '{{baseUrl}}/product';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/product',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/product")
  .get()
  .addHeader("accept-language", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/product',
  headers: {
    'accept-language': ''
  }
};

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}}/product',
  headers: {'accept-language': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'accept-language': ''
});

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}}/product',
  headers: {'accept-language': ''}
};

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

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

const url = '{{baseUrl}}/product';
const options = {method: 'GET', headers: {'accept-language': ''}};

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

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/product" in
let headers = Header.add (Header.init ()) "accept-language" "" in

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

 "{{baseUrl}}/product",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/product', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/product');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept-language' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/product');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/product' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/product' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept-language': "" }

conn.request("GET", "/baseUrl/product", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/product"

headers = {"accept-language": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/product"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/product")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/product') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/product";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/product \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/product

import Foundation

let headers = ["accept-language": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/product")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/search/freetext");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/search/freetext" {:headers {:accept-language ""}
                                                            :content-type :json
                                                            :form-params {:currencyCode ""
                                                                          :destId 0
                                                                          :searchTypes []
                                                                          :sortOrder ""
                                                                          :text ""
                                                                          :topX ""}})

require "http/client"

url = "{{baseUrl}}/search/freetext"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\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}}/search/freetext"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\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}}/search/freetext");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/search/freetext"

	payload := strings.NewReader("{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("accept-language", "")
	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/search/freetext HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "currencyCode": "",
  "destId": 0,
  "searchTypes": [],
  "sortOrder": "",
  "text": "",
  "topX": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/search/freetext")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/search/freetext"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\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  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/search/freetext")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/search/freetext")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  currencyCode: '',
  destId: 0,
  searchTypes: [],
  sortOrder: '',
  text: '',
  topX: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/search/freetext');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/search/freetext',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    currencyCode: '',
    destId: 0,
    searchTypes: [],
    sortOrder: '',
    text: '',
    topX: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/search/freetext';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","destId":0,"searchTypes":[],"sortOrder":"","text":"","topX":""}'
};

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}}/search/freetext',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "currencyCode": "",\n  "destId": 0,\n  "searchTypes": [],\n  "sortOrder": "",\n  "text": "",\n  "topX": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/search/freetext")
  .post(body)
  .addHeader("accept-language", "")
  .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/search/freetext',
  headers: {
    'accept-language': '',
    '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({
  currencyCode: '',
  destId: 0,
  searchTypes: [],
  sortOrder: '',
  text: '',
  topX: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/search/freetext',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {
    currencyCode: '',
    destId: 0,
    searchTypes: [],
    sortOrder: '',
    text: '',
    topX: ''
  },
  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}}/search/freetext');

req.headers({
  'accept-language': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  currencyCode: '',
  destId: 0,
  searchTypes: [],
  sortOrder: '',
  text: '',
  topX: ''
});

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}}/search/freetext',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    currencyCode: '',
    destId: 0,
    searchTypes: [],
    sortOrder: '',
    text: '',
    topX: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/search/freetext';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","destId":0,"searchTypes":[],"sortOrder":"","text":"","topX":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"currencyCode": @"",
                              @"destId": @0,
                              @"searchTypes": @[  ],
                              @"sortOrder": @"",
                              @"text": @"",
                              @"topX": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/search/freetext"]
                                                       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}}/search/freetext" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/search/freetext",
  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([
    'currencyCode' => '',
    'destId' => 0,
    'searchTypes' => [
        
    ],
    'sortOrder' => '',
    'text' => '',
    'topX' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/search/freetext', [
  'body' => '{
  "currencyCode": "",
  "destId": 0,
  "searchTypes": [],
  "sortOrder": "",
  "text": "",
  "topX": ""
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/search/freetext');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept-language' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'currencyCode' => '',
  'destId' => 0,
  'searchTypes' => [
    
  ],
  'sortOrder' => '',
  'text' => '',
  'topX' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'currencyCode' => '',
  'destId' => 0,
  'searchTypes' => [
    
  ],
  'sortOrder' => '',
  'text' => '',
  'topX' => ''
]));
$request->setRequestUrl('{{baseUrl}}/search/freetext');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept-language' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/search/freetext' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "destId": 0,
  "searchTypes": [],
  "sortOrder": "",
  "text": "",
  "topX": ""
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/search/freetext' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "destId": 0,
  "searchTypes": [],
  "sortOrder": "",
  "text": "",
  "topX": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}"

headers = {
    'accept-language': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/search/freetext", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/search/freetext"

payload = {
    "currencyCode": "",
    "destId": 0,
    "searchTypes": [],
    "sortOrder": "",
    "text": "",
    "topX": ""
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/search/freetext"

payload <- "{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('accept-language' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/search/freetext")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\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/search/freetext') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"searchTypes\": [],\n  \"sortOrder\": \"\",\n  \"text\": \"\",\n  \"topX\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/search/freetext";

    let payload = json!({
        "currencyCode": "",
        "destId": 0,
        "searchTypes": (),
        "sortOrder": "",
        "text": "",
        "topX": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "currencyCode": "",
  "destId": 0,
  "searchTypes": [],
  "sortOrder": "",
  "text": "",
  "topX": ""
}' |  \
  http POST {{baseUrl}}/search/freetext \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "currencyCode": "",\n  "destId": 0,\n  "searchTypes": [],\n  "sortOrder": "",\n  "text": "",\n  "topX": ""\n}' \
  --output-document \
  - {{baseUrl}}/search/freetext

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "currencyCode": "",
  "destId": 0,
  "searchTypes": [],
  "sortOrder": "",
  "text": "",
  "topX": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/search/freetext")! 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}}/search/products/codes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/search/products/codes" {:headers {:accept-language ""}
                                                                  :content-type :json
                                                                  :form-params {:currencyCode ""
                                                                                :productCodes []}})

require "http/client"

url = "{{baseUrl}}/search/products/codes"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\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}}/search/products/codes"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\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}}/search/products/codes");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/search/products/codes"

	payload := strings.NewReader("{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("accept-language", "")
	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/search/products/codes HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "currencyCode": "",
  "productCodes": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/search/products/codes")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/search/products/codes"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\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  \"currencyCode\": \"\",\n  \"productCodes\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/search/products/codes")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/search/products/codes")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}")
  .asString();

const data = JSON.stringify({
  currencyCode: '',
  productCodes: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/search/products/codes');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/search/products/codes',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {currencyCode: '', productCodes: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/search/products/codes';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","productCodes":[]}'
};

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}}/search/products/codes',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "currencyCode": "",\n  "productCodes": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/search/products/codes")
  .post(body)
  .addHeader("accept-language", "")
  .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/search/products/codes',
  headers: {
    'accept-language': '',
    '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({currencyCode: '', productCodes: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/search/products/codes',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {currencyCode: '', productCodes: []},
  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}}/search/products/codes');

req.headers({
  'accept-language': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  currencyCode: '',
  productCodes: []
});

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}}/search/products/codes',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {currencyCode: '', productCodes: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/search/products/codes';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"currencyCode":"","productCodes":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"currencyCode": @"",
                              @"productCodes": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/search/products/codes"]
                                                       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}}/search/products/codes" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/search/products/codes",
  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([
    'currencyCode' => '',
    'productCodes' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/search/products/codes', [
  'body' => '{
  "currencyCode": "",
  "productCodes": []
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/search/products/codes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept-language' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'currencyCode' => '',
  'productCodes' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'currencyCode' => '',
  'productCodes' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/search/products/codes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept-language' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/search/products/codes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "productCodes": []
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/search/products/codes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "currencyCode": "",
  "productCodes": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}"

headers = {
    'accept-language': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/search/products/codes", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/search/products/codes"

payload = {
    "currencyCode": "",
    "productCodes": []
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/search/products/codes"

payload <- "{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('accept-language' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/search/products/codes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\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/search/products/codes') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"currencyCode\": \"\",\n  \"productCodes\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/search/products/codes";

    let payload = json!({
        "currencyCode": "",
        "productCodes": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "currencyCode": "",
  "productCodes": []
}' |  \
  http POST {{baseUrl}}/search/products/codes \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "currencyCode": "",\n  "productCodes": []\n}' \
  --output-document \
  - {{baseUrl}}/search/products/codes

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "currencyCode": "",
  "productCodes": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/search/products/codes")! 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}}/search/products");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/search/products" {:headers {:accept-language ""}
                                                            :content-type :json
                                                            :form-params {:catId 0
                                                                          :currencyCode ""
                                                                          :destId 0
                                                                          :endDate ""
                                                                          :seoId ""
                                                                          :sortOrder ""
                                                                          :startDate ""
                                                                          :subCatId 0
                                                                          :topX ""}})

require "http/client"

url = "{{baseUrl}}/search/products"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\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}}/search/products"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\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}}/search/products");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/search/products"

	payload := strings.NewReader("{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("accept-language", "")
	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/search/products HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 154

{
  "catId": 0,
  "currencyCode": "",
  "destId": 0,
  "endDate": "",
  "seoId": "",
  "sortOrder": "",
  "startDate": "",
  "subCatId": 0,
  "topX": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/search/products")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/search/products"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\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  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/search/products")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/search/products")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  catId: 0,
  currencyCode: '',
  destId: 0,
  endDate: '',
  seoId: '',
  sortOrder: '',
  startDate: '',
  subCatId: 0,
  topX: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/search/products');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/search/products',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    catId: 0,
    currencyCode: '',
    destId: 0,
    endDate: '',
    seoId: '',
    sortOrder: '',
    startDate: '',
    subCatId: 0,
    topX: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/search/products';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"catId":0,"currencyCode":"","destId":0,"endDate":"","seoId":"","sortOrder":"","startDate":"","subCatId":0,"topX":""}'
};

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}}/search/products',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "catId": 0,\n  "currencyCode": "",\n  "destId": 0,\n  "endDate": "",\n  "seoId": "",\n  "sortOrder": "",\n  "startDate": "",\n  "subCatId": 0,\n  "topX": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/search/products")
  .post(body)
  .addHeader("accept-language", "")
  .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/search/products',
  headers: {
    'accept-language': '',
    '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({
  catId: 0,
  currencyCode: '',
  destId: 0,
  endDate: '',
  seoId: '',
  sortOrder: '',
  startDate: '',
  subCatId: 0,
  topX: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/search/products',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {
    catId: 0,
    currencyCode: '',
    destId: 0,
    endDate: '',
    seoId: '',
    sortOrder: '',
    startDate: '',
    subCatId: 0,
    topX: ''
  },
  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}}/search/products');

req.headers({
  'accept-language': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  catId: 0,
  currencyCode: '',
  destId: 0,
  endDate: '',
  seoId: '',
  sortOrder: '',
  startDate: '',
  subCatId: 0,
  topX: ''
});

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}}/search/products',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {
    catId: 0,
    currencyCode: '',
    destId: 0,
    endDate: '',
    seoId: '',
    sortOrder: '',
    startDate: '',
    subCatId: 0,
    topX: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/search/products';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"catId":0,"currencyCode":"","destId":0,"endDate":"","seoId":"","sortOrder":"","startDate":"","subCatId":0,"topX":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"catId": @0,
                              @"currencyCode": @"",
                              @"destId": @0,
                              @"endDate": @"",
                              @"seoId": @"",
                              @"sortOrder": @"",
                              @"startDate": @"",
                              @"subCatId": @0,
                              @"topX": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/search/products"]
                                                       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}}/search/products" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/search/products",
  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([
    'catId' => 0,
    'currencyCode' => '',
    'destId' => 0,
    'endDate' => '',
    'seoId' => '',
    'sortOrder' => '',
    'startDate' => '',
    'subCatId' => 0,
    'topX' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/search/products', [
  'body' => '{
  "catId": 0,
  "currencyCode": "",
  "destId": 0,
  "endDate": "",
  "seoId": "",
  "sortOrder": "",
  "startDate": "",
  "subCatId": 0,
  "topX": ""
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/search/products');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept-language' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'catId' => 0,
  'currencyCode' => '',
  'destId' => 0,
  'endDate' => '',
  'seoId' => '',
  'sortOrder' => '',
  'startDate' => '',
  'subCatId' => 0,
  'topX' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'catId' => 0,
  'currencyCode' => '',
  'destId' => 0,
  'endDate' => '',
  'seoId' => '',
  'sortOrder' => '',
  'startDate' => '',
  'subCatId' => 0,
  'topX' => ''
]));
$request->setRequestUrl('{{baseUrl}}/search/products');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept-language' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/search/products' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "catId": 0,
  "currencyCode": "",
  "destId": 0,
  "endDate": "",
  "seoId": "",
  "sortOrder": "",
  "startDate": "",
  "subCatId": 0,
  "topX": ""
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/search/products' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "catId": 0,
  "currencyCode": "",
  "destId": 0,
  "endDate": "",
  "seoId": "",
  "sortOrder": "",
  "startDate": "",
  "subCatId": 0,
  "topX": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}"

headers = {
    'accept-language': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/search/products", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/search/products"

payload = {
    "catId": 0,
    "currencyCode": "",
    "destId": 0,
    "endDate": "",
    "seoId": "",
    "sortOrder": "",
    "startDate": "",
    "subCatId": 0,
    "topX": ""
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/search/products"

payload <- "{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('accept-language' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/search/products")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\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/search/products') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"catId\": 0,\n  \"currencyCode\": \"\",\n  \"destId\": 0,\n  \"endDate\": \"\",\n  \"seoId\": \"\",\n  \"sortOrder\": \"\",\n  \"startDate\": \"\",\n  \"subCatId\": 0,\n  \"topX\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/search/products";

    let payload = json!({
        "catId": 0,
        "currencyCode": "",
        "destId": 0,
        "endDate": "",
        "seoId": "",
        "sortOrder": "",
        "startDate": "",
        "subCatId": 0,
        "topX": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "catId": 0,
  "currencyCode": "",
  "destId": 0,
  "endDate": "",
  "seoId": "",
  "sortOrder": "",
  "startDate": "",
  "subCatId": 0,
  "topX": ""
}' |  \
  http POST {{baseUrl}}/search/products \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "catId": 0,\n  "currencyCode": "",\n  "destId": 0,\n  "endDate": "",\n  "seoId": "",\n  "sortOrder": "",\n  "startDate": "",\n  "subCatId": 0,\n  "topX": ""\n}' \
  --output-document \
  - {{baseUrl}}/search/products

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "catId": 0,
  "currencyCode": "",
  "destId": 0,
  "endDate": "",
  "seoId": "",
  "sortOrder": "",
  "startDate": "",
  "subCatId": 0,
  "topX": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/search/products")! 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}}/taxonomy/attractions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/taxonomy/attractions" {:headers {:accept-language ""}
                                                                 :content-type :json
                                                                 :form-params {:destId 0
                                                                               :sortOrder ""
                                                                               :topX ""}})

require "http/client"

url = "{{baseUrl}}/taxonomy/attractions"
headers = HTTP::Headers{
  "accept-language" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\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}}/taxonomy/attractions"),
    Headers =
    {
        { "accept-language", "" },
    },
    Content = new StringContent("{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\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}}/taxonomy/attractions");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept-language", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/taxonomy/attractions"

	payload := strings.NewReader("{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("accept-language", "")
	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/taxonomy/attractions HTTP/1.1
Accept-Language: 
Content-Type: application/json
Host: example.com
Content-Length: 50

{
  "destId": 0,
  "sortOrder": "",
  "topX": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/taxonomy/attractions")
  .setHeader("accept-language", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/taxonomy/attractions"))
    .header("accept-language", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\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  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/taxonomy/attractions")
  .post(body)
  .addHeader("accept-language", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/taxonomy/attractions")
  .header("accept-language", "")
  .header("content-type", "application/json")
  .body("{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  destId: 0,
  sortOrder: '',
  topX: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/taxonomy/attractions');
xhr.setRequestHeader('accept-language', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/taxonomy/attractions',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {destId: 0, sortOrder: '', topX: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/taxonomy/attractions';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"destId":0,"sortOrder":"","topX":""}'
};

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}}/taxonomy/attractions',
  method: 'POST',
  headers: {
    'accept-language': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "destId": 0,\n  "sortOrder": "",\n  "topX": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/taxonomy/attractions")
  .post(body)
  .addHeader("accept-language", "")
  .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/taxonomy/attractions',
  headers: {
    'accept-language': '',
    '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({destId: 0, sortOrder: '', topX: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/taxonomy/attractions',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: {destId: 0, sortOrder: '', topX: ''},
  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}}/taxonomy/attractions');

req.headers({
  'accept-language': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  destId: 0,
  sortOrder: '',
  topX: ''
});

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}}/taxonomy/attractions',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  data: {destId: 0, sortOrder: '', topX: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/taxonomy/attractions';
const options = {
  method: 'POST',
  headers: {'accept-language': '', 'content-type': 'application/json'},
  body: '{"destId":0,"sortOrder":"","topX":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept-language": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"destId": @0,
                              @"sortOrder": @"",
                              @"topX": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/taxonomy/attractions"]
                                                       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}}/taxonomy/attractions" in
let headers = Header.add_list (Header.init ()) [
  ("accept-language", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/taxonomy/attractions",
  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([
    'destId' => 0,
    'sortOrder' => '',
    'topX' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept-language: ",
    "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}}/taxonomy/attractions', [
  'body' => '{
  "destId": 0,
  "sortOrder": "",
  "topX": ""
}',
  'headers' => [
    'accept-language' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/taxonomy/attractions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept-language' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'destId' => 0,
  'sortOrder' => '',
  'topX' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'destId' => 0,
  'sortOrder' => '',
  'topX' => ''
]));
$request->setRequestUrl('{{baseUrl}}/taxonomy/attractions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept-language' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/taxonomy/attractions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "destId": 0,
  "sortOrder": "",
  "topX": ""
}'

$headers=@{}
$headers.Add("accept-language", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/taxonomy/attractions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "destId": 0,
  "sortOrder": "",
  "topX": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}"

headers = {
    'accept-language': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/taxonomy/attractions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/taxonomy/attractions"

payload = {
    "destId": 0,
    "sortOrder": "",
    "topX": ""
}
headers = {
    "accept-language": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/taxonomy/attractions"

payload <- "{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('accept-language' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/taxonomy/attractions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept-language"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\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/taxonomy/attractions') do |req|
  req.headers['accept-language'] = ''
  req.body = "{\n  \"destId\": 0,\n  \"sortOrder\": \"\",\n  \"topX\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/taxonomy/attractions";

    let payload = json!({
        "destId": 0,
        "sortOrder": "",
        "topX": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "destId": 0,
  "sortOrder": "",
  "topX": ""
}' |  \
  http POST {{baseUrl}}/taxonomy/attractions \
  accept-language:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept-language: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "destId": 0,\n  "sortOrder": "",\n  "topX": ""\n}' \
  --output-document \
  - {{baseUrl}}/taxonomy/attractions

import Foundation

let headers = [
  "accept-language": "",
  "content-type": "application/json"
]
let parameters = [
  "destId": 0,
  "sortOrder": "",
  "topX": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/taxonomy/attractions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/taxonomy/categories");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/taxonomy/categories" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/taxonomy/categories"
headers = HTTP::Headers{
  "accept-language" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/taxonomy/categories"),
    Headers =
    {
        { "accept-language", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/taxonomy/categories");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/taxonomy/categories"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept-language", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/taxonomy/categories HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/taxonomy/categories")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/taxonomy/categories"))
    .header("accept-language", "")
    .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}}/taxonomy/categories")
  .get()
  .addHeader("accept-language", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/taxonomy/categories")
  .header("accept-language", "")
  .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}}/taxonomy/categories');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/taxonomy/categories',
  headers: {'accept-language': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/taxonomy/categories';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/taxonomy/categories',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/taxonomy/categories")
  .get()
  .addHeader("accept-language", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/taxonomy/categories',
  headers: {
    'accept-language': ''
  }
};

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}}/taxonomy/categories',
  headers: {'accept-language': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/taxonomy/categories');

req.headers({
  'accept-language': ''
});

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}}/taxonomy/categories',
  headers: {'accept-language': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/taxonomy/categories';
const options = {method: 'GET', headers: {'accept-language': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/taxonomy/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/taxonomy/categories" in
let headers = Header.add (Header.init ()) "accept-language" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/taxonomy/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/taxonomy/categories', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/taxonomy/categories');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept-language' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/taxonomy/categories');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/taxonomy/categories' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/taxonomy/categories' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept-language': "" }

conn.request("GET", "/baseUrl/taxonomy/categories", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/taxonomy/categories"

headers = {"accept-language": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/taxonomy/categories"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/taxonomy/categories")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/taxonomy/categories') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/taxonomy/categories";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/taxonomy/categories \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/taxonomy/categories

import Foundation

let headers = ["accept-language": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/taxonomy/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/taxonomy/destinations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-language: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/taxonomy/destinations" {:headers {:accept-language ""}})

require "http/client"

url = "{{baseUrl}}/taxonomy/destinations"
headers = HTTP::Headers{
  "accept-language" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/taxonomy/destinations"),
    Headers =
    {
        { "accept-language", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/taxonomy/destinations");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-language", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/taxonomy/destinations"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept-language", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/taxonomy/destinations HTTP/1.1
Accept-Language: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/taxonomy/destinations")
  .setHeader("accept-language", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/taxonomy/destinations"))
    .header("accept-language", "")
    .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}}/taxonomy/destinations")
  .get()
  .addHeader("accept-language", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/taxonomy/destinations")
  .header("accept-language", "")
  .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}}/taxonomy/destinations');
xhr.setRequestHeader('accept-language', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/taxonomy/destinations',
  headers: {'accept-language': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/taxonomy/destinations';
const options = {method: 'GET', headers: {'accept-language': ''}};

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}}/taxonomy/destinations',
  method: 'GET',
  headers: {
    'accept-language': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/taxonomy/destinations")
  .get()
  .addHeader("accept-language", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/taxonomy/destinations',
  headers: {
    'accept-language': ''
  }
};

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}}/taxonomy/destinations',
  headers: {'accept-language': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/taxonomy/destinations');

req.headers({
  'accept-language': ''
});

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}}/taxonomy/destinations',
  headers: {'accept-language': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/taxonomy/destinations';
const options = {method: 'GET', headers: {'accept-language': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept-language": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/taxonomy/destinations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/taxonomy/destinations" in
let headers = Header.add (Header.init ()) "accept-language" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/taxonomy/destinations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-language: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/taxonomy/destinations', [
  'headers' => [
    'accept-language' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/taxonomy/destinations');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept-language' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/taxonomy/destinations');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-language' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/taxonomy/destinations' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-language", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/taxonomy/destinations' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept-language': "" }

conn.request("GET", "/baseUrl/taxonomy/destinations", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/taxonomy/destinations"

headers = {"accept-language": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/taxonomy/destinations"

response <- VERB("GET", url, add_headers('accept-language' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/taxonomy/destinations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept-language"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/taxonomy/destinations') do |req|
  req.headers['accept-language'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/taxonomy/destinations";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-language", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/taxonomy/destinations \
  accept-language:''

wget --quiet \
  --method GET \
  --header 'accept-language: ' \
  --output-document \
  - {{baseUrl}}/taxonomy/destinations

import Foundation

let headers = ["accept-language": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/taxonomy/destinations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()