CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/articles/categories")

require "http/client"

url = "{{baseUrl}}/articles/categories"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/articles/categories"

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

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

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

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

}

GET /baseUrl/articles/categories HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles/categories"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles/categories")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/articles/categories")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/articles/categories');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/articles/categories';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles/categories',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles/categories',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

const url = '{{baseUrl}}/articles/categories';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles/categories" in

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

 "{{baseUrl}}/articles/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/articles/categories');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/articles/categories")

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

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

import requests

url = "{{baseUrl}}/articles/categories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles/categories"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles/categories")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/articles/categories') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/articles/categories

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/articles"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/articles"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/articles

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/categories/taxonomy")

require "http/client"

url = "{{baseUrl}}/categories/taxonomy"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/categories/taxonomy"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/categories/taxonomy")

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

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

import requests

url = "{{baseUrl}}/categories/taxonomy"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories/taxonomy"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories/taxonomy")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/categories/taxonomy

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories/:uuid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/categories/:uuid")

require "http/client"

url = "{{baseUrl}}/categories/:uuid"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/categories/:uuid"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/categories/:uuid');

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}}/categories/:uuid'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories/:uuid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories/:uuid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/categories/:uuid")

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

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

import requests

url = "{{baseUrl}}/categories/:uuid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories/:uuid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories/:uuid")

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/categories/:uuid') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/categories/:uuid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/categories/:uuid

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories/:product_type/:category");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/categories/:product_type/:category")

require "http/client"

url = "{{baseUrl}}/categories/:product_type/:category"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/categories/:product_type/:category"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories/:product_type/:category'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/categories/:product_type/:category")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/categories/:product_type/:category');

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}}/categories/:product_type/:category'
};

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

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

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

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

 "{{baseUrl}}/categories/:product_type/:category",
  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}}/categories/:product_type/:category');

echo $response->getBody();

setUrl('{{baseUrl}}/categories/:product_type/:category');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories/:product_type/:category' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories/:product_type/:category' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/categories/:product_type/:category")

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

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

import requests

url = "{{baseUrl}}/categories/:product_type/:category"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories/:product_type/:category"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories/:product_type/:category")

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/categories/:product_type/:category') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/categories/:product_type/:category

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/categories/:product_type/:category

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/categories"

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

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

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

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/categories HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/categories"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/categories")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/categories")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/categories');

xhr.send(data);

import axios from 'axios';

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

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/categories',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/categories',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/categories" in

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

 "{{baseUrl}}/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/categories');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/categories"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/categories') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/categories

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/categories/flat")

require "http/client"

url = "{{baseUrl}}/categories/flat"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/categories/flat"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/categories/flat")

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

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

import requests

url = "{{baseUrl}}/categories/flat"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories/flat"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories/flat")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/categories/flat

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/comparison_shopping_pages/:id/listings" {:query-params {:condition ""}})

require "http/client"

url = "{{baseUrl}}/comparison_shopping_pages/:id/listings?condition="

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

var client = new RestClient("{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/comparison_shopping_pages/:id/listings?condition="

	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/comparison_shopping_pages/:id/listings?condition= HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/comparison_shopping_pages/:id/listings?condition="))
    .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}}/comparison_shopping_pages/:id/listings?condition=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=")
  .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}}/comparison_shopping_pages/:id/listings?condition=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/comparison_shopping_pages/:id/listings',
  params: {condition: ''}
};

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

const url = '{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=';
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}}/comparison_shopping_pages/:id/listings?condition=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/comparison_shopping_pages/:id/listings');

req.query({
  condition: ''
});

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}}/comparison_shopping_pages/:id/listings',
  params: {condition: ''}
};

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

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

const url = '{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=';
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}}/comparison_shopping_pages/:id/listings?condition="]
                                                       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}}/comparison_shopping_pages/:id/listings?condition=" in

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

 "{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=",
  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}}/comparison_shopping_pages/:id/listings?condition=');

echo $response->getBody();

setUrl('{{baseUrl}}/comparison_shopping_pages/:id/listings');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'condition' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/comparison_shopping_pages/:id/listings');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'condition' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/comparison_shopping_pages/:id/listings?condition=")

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

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

import requests

url = "{{baseUrl}}/comparison_shopping_pages/:id/listings"

querystring = {"condition":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/comparison_shopping_pages/:id/listings"

queryString <- list(condition = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/comparison_shopping_pages/:id/listings?condition=")

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/comparison_shopping_pages/:id/listings') do |req|
  req.params['condition'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("condition", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/comparison_shopping_pages/:id/listings?condition='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/comparison_shopping_pages/:id/listings?condition='

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/comparison_shopping_pages"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/comparison_shopping_pages"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/comparison_shopping_pages

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/comparison_shopping_pages/find")

require "http/client"

url = "{{baseUrl}}/comparison_shopping_pages/find"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/comparison_shopping_pages/find"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/comparison_shopping_pages/find")

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

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

import requests

url = "{{baseUrl}}/comparison_shopping_pages/find"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/comparison_shopping_pages/find"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/comparison_shopping_pages/find")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/comparison_shopping_pages/find

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/comparison_shopping_pages/:id/reviews");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/comparison_shopping_pages/:id/reviews")

require "http/client"

url = "{{baseUrl}}/comparison_shopping_pages/:id/reviews"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/comparison_shopping_pages/:id/reviews"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/comparison_shopping_pages/:id/reviews'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/comparison_shopping_pages/:id/reviews")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/comparison_shopping_pages/:id/reviews');

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}}/comparison_shopping_pages/:id/reviews'
};

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

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

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

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

 "{{baseUrl}}/comparison_shopping_pages/:id/reviews",
  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}}/comparison_shopping_pages/:id/reviews');

echo $response->getBody();

setUrl('{{baseUrl}}/comparison_shopping_pages/:id/reviews');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/comparison_shopping_pages/:id/reviews' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/comparison_shopping_pages/:id/reviews' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/comparison_shopping_pages/:id/reviews")

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

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

import requests

url = "{{baseUrl}}/comparison_shopping_pages/:id/reviews"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/comparison_shopping_pages/:id/reviews"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/comparison_shopping_pages/:id/reviews")

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/comparison_shopping_pages/:id/reviews') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/comparison_shopping_pages/:id/reviews

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/comparison_shopping_pages/:id/reviews

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/comparison_shopping_pages/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/comparison_shopping_pages/:id")

require "http/client"

url = "{{baseUrl}}/comparison_shopping_pages/:id"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/comparison_shopping_pages/:id"

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/comparison_shopping_pages/:id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/comparison_shopping_pages/:id');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/comparison_shopping_pages/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/comparison_shopping_pages/:id');

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/comparison_shopping_pages/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/comparison_shopping_pages/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/comparison_shopping_pages/:id")

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

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

import requests

url = "{{baseUrl}}/comparison_shopping_pages/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/comparison_shopping_pages/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/comparison_shopping_pages/:id")

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/comparison_shopping_pages/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/comparison_shopping_pages/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/comparison_shopping_pages/:id

import Foundation

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/conversations/:id/offer" {:content-type :json
                                                                    :form-params {:message ""
                                                                                  :price ""
                                                                                  :shipping_price ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/conversations/:id/offer"

	payload := strings.NewReader("{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/conversations/:id/offer HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "message": "",
  "price": "",
  "shipping_price": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/conversations/:id/offer")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/conversations/:id/offer")
  .header("content-type", "application/json")
  .body("{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  message: '',
  price: '',
  shipping_price: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/conversations/:id/offer');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/conversations/:id/offer',
  headers: {'content-type': 'application/json'},
  data: {message: '', price: '', shipping_price: ''}
};

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

const url = '{{baseUrl}}/conversations/:id/offer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"message":"","price":"","shipping_price":""}'
};

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}}/conversations/:id/offer',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "message": "",\n  "price": "",\n  "shipping_price": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/conversations/:id/offer")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/conversations/:id/offer',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({message: '', price: '', shipping_price: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/conversations/:id/offer',
  headers: {'content-type': 'application/json'},
  body: {message: '', price: '', shipping_price: ''},
  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}}/conversations/:id/offer');

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

req.type('json');
req.send({
  message: '',
  price: '',
  shipping_price: ''
});

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}}/conversations/:id/offer',
  headers: {'content-type': 'application/json'},
  data: {message: '', price: '', shipping_price: ''}
};

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

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

const url = '{{baseUrl}}/conversations/:id/offer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"message":"","price":"","shipping_price":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"message": @"",
                              @"price": @"",
                              @"shipping_price": @"" };

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

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

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

 "{{baseUrl}}/conversations/:id/offer",
  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([
    'message' => '',
    'price' => '',
    'shipping_price' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/conversations/:id/offer', [
  'body' => '{
  "message": "",
  "price": "",
  "shipping_price": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/conversations/:id/offer');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'message' => '',
  'price' => '',
  'shipping_price' => ''
]));

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

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

append(json_encode([
  'message' => '',
  'price' => '',
  'shipping_price' => ''
]));
$request->setRequestUrl('{{baseUrl}}/conversations/:id/offer');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/conversations/:id/offer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": "",
  "price": "",
  "shipping_price": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/conversations/:id/offer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": "",
  "price": "",
  "shipping_price": ""
}'

import http.client

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

payload = "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}"

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

conn.request("POST", "/baseUrl/conversations/:id/offer", payload, headers)

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

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

import requests

url = "{{baseUrl}}/conversations/:id/offer"

payload = {
    "message": "",
    "price": "",
    "shipping_price": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/conversations/:id/offer"

payload <- "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/conversations/:id/offer")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\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/conversations/:id/offer') do |req|
  req.body = "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "message": "",
        "price": "",
        "shipping_price": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "message": "",
  "price": "",
  "shipping_price": ""
}' |  \
  http POST {{baseUrl}}/conversations/:id/offer \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "message": "",\n  "price": "",\n  "shipping_price": ""\n}' \
  --output-document \
  - {{baseUrl}}/conversations/:id/offer

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "message": "",
  "price": "",
  "shipping_price": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/conversations/:conversation_id/offer" {:content-type :json
                                                                                 :form-params {:country_code ""
                                                                                               :layaway_terms_slug ""
                                                                                               :message ""
                                                                                               :offer_items [{:listing_id ""
                                                                                                              :price ""
                                                                                                              :shipping_price ""}]
                                                                                               :price {:amount ""
                                                                                                       :currency ""}
                                                                                               :quantity ""
                                                                                               :recipient_id ""
                                                                                               :region_code ""
                                                                                               :shipping_price {:amount ""
                                                                                                                :currency ""}}})

require "http/client"

url = "{{baseUrl}}/conversations/:conversation_id/offer"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\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}}/conversations/:conversation_id/offer"),
    Content = new StringContent("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\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}}/conversations/:conversation_id/offer");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/conversations/:conversation_id/offer"

	payload := strings.NewReader("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}")

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

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

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

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

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

}

POST /baseUrl/conversations/:conversation_id/offer HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 355

{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/conversations/:conversation_id/offer")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/conversations/:conversation_id/offer"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\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  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/conversations/:conversation_id/offer")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/conversations/:conversation_id/offer")
  .header("content-type", "application/json")
  .body("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  country_code: '',
  layaway_terms_slug: '',
  message: '',
  offer_items: [
    {
      listing_id: '',
      price: '',
      shipping_price: ''
    }
  ],
  price: {
    amount: '',
    currency: ''
  },
  quantity: '',
  recipient_id: '',
  region_code: '',
  shipping_price: {
    amount: '',
    currency: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/conversations/:conversation_id/offer');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/conversations/:conversation_id/offer',
  headers: {'content-type': 'application/json'},
  data: {
    country_code: '',
    layaway_terms_slug: '',
    message: '',
    offer_items: [{listing_id: '', price: '', shipping_price: ''}],
    price: {amount: '', currency: ''},
    quantity: '',
    recipient_id: '',
    region_code: '',
    shipping_price: {amount: '', currency: ''}
  }
};

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

const url = '{{baseUrl}}/conversations/:conversation_id/offer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"country_code":"","layaway_terms_slug":"","message":"","offer_items":[{"listing_id":"","price":"","shipping_price":""}],"price":{"amount":"","currency":""},"quantity":"","recipient_id":"","region_code":"","shipping_price":{"amount":"","currency":""}}'
};

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}}/conversations/:conversation_id/offer',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "country_code": "",\n  "layaway_terms_slug": "",\n  "message": "",\n  "offer_items": [\n    {\n      "listing_id": "",\n      "price": "",\n      "shipping_price": ""\n    }\n  ],\n  "price": {\n    "amount": "",\n    "currency": ""\n  },\n  "quantity": "",\n  "recipient_id": "",\n  "region_code": "",\n  "shipping_price": {\n    "amount": "",\n    "currency": ""\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  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/conversations/:conversation_id/offer")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/conversations/:conversation_id/offer',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  country_code: '',
  layaway_terms_slug: '',
  message: '',
  offer_items: [{listing_id: '', price: '', shipping_price: ''}],
  price: {amount: '', currency: ''},
  quantity: '',
  recipient_id: '',
  region_code: '',
  shipping_price: {amount: '', currency: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/conversations/:conversation_id/offer',
  headers: {'content-type': 'application/json'},
  body: {
    country_code: '',
    layaway_terms_slug: '',
    message: '',
    offer_items: [{listing_id: '', price: '', shipping_price: ''}],
    price: {amount: '', currency: ''},
    quantity: '',
    recipient_id: '',
    region_code: '',
    shipping_price: {amount: '', currency: ''}
  },
  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}}/conversations/:conversation_id/offer');

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

req.type('json');
req.send({
  country_code: '',
  layaway_terms_slug: '',
  message: '',
  offer_items: [
    {
      listing_id: '',
      price: '',
      shipping_price: ''
    }
  ],
  price: {
    amount: '',
    currency: ''
  },
  quantity: '',
  recipient_id: '',
  region_code: '',
  shipping_price: {
    amount: '',
    currency: ''
  }
});

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}}/conversations/:conversation_id/offer',
  headers: {'content-type': 'application/json'},
  data: {
    country_code: '',
    layaway_terms_slug: '',
    message: '',
    offer_items: [{listing_id: '', price: '', shipping_price: ''}],
    price: {amount: '', currency: ''},
    quantity: '',
    recipient_id: '',
    region_code: '',
    shipping_price: {amount: '', currency: ''}
  }
};

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

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

const url = '{{baseUrl}}/conversations/:conversation_id/offer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"country_code":"","layaway_terms_slug":"","message":"","offer_items":[{"listing_id":"","price":"","shipping_price":""}],"price":{"amount":"","currency":""},"quantity":"","recipient_id":"","region_code":"","shipping_price":{"amount":"","currency":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"country_code": @"",
                              @"layaway_terms_slug": @"",
                              @"message": @"",
                              @"offer_items": @[ @{ @"listing_id": @"", @"price": @"", @"shipping_price": @"" } ],
                              @"price": @{ @"amount": @"", @"currency": @"" },
                              @"quantity": @"",
                              @"recipient_id": @"",
                              @"region_code": @"",
                              @"shipping_price": @{ @"amount": @"", @"currency": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/conversations/:conversation_id/offer"]
                                                       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}}/conversations/:conversation_id/offer" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/conversations/:conversation_id/offer",
  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([
    'country_code' => '',
    'layaway_terms_slug' => '',
    'message' => '',
    'offer_items' => [
        [
                'listing_id' => '',
                'price' => '',
                'shipping_price' => ''
        ]
    ],
    'price' => [
        'amount' => '',
        'currency' => ''
    ],
    'quantity' => '',
    'recipient_id' => '',
    'region_code' => '',
    'shipping_price' => [
        'amount' => '',
        'currency' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/conversations/:conversation_id/offer', [
  'body' => '{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/conversations/:conversation_id/offer');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'country_code' => '',
  'layaway_terms_slug' => '',
  'message' => '',
  'offer_items' => [
    [
        'listing_id' => '',
        'price' => '',
        'shipping_price' => ''
    ]
  ],
  'price' => [
    'amount' => '',
    'currency' => ''
  ],
  'quantity' => '',
  'recipient_id' => '',
  'region_code' => '',
  'shipping_price' => [
    'amount' => '',
    'currency' => ''
  ]
]));

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

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

append(json_encode([
  'country_code' => '',
  'layaway_terms_slug' => '',
  'message' => '',
  'offer_items' => [
    [
        'listing_id' => '',
        'price' => '',
        'shipping_price' => ''
    ]
  ],
  'price' => [
    'amount' => '',
    'currency' => ''
  ],
  'quantity' => '',
  'recipient_id' => '',
  'region_code' => '',
  'shipping_price' => [
    'amount' => '',
    'currency' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/conversations/:conversation_id/offer');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/conversations/:conversation_id/offer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/conversations/:conversation_id/offer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}'

import http.client

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

payload = "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/conversations/:conversation_id/offer", payload, headers)

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

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

import requests

url = "{{baseUrl}}/conversations/:conversation_id/offer"

payload = {
    "country_code": "",
    "layaway_terms_slug": "",
    "message": "",
    "offer_items": [
        {
            "listing_id": "",
            "price": "",
            "shipping_price": ""
        }
    ],
    "price": {
        "amount": "",
        "currency": ""
    },
    "quantity": "",
    "recipient_id": "",
    "region_code": "",
    "shipping_price": {
        "amount": "",
        "currency": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/conversations/:conversation_id/offer"

payload <- "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/conversations/:conversation_id/offer")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\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/conversations/:conversation_id/offer') do |req|
  req.body = "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "country_code": "",
        "layaway_terms_slug": "",
        "message": "",
        "offer_items": (
            json!({
                "listing_id": "",
                "price": "",
                "shipping_price": ""
            })
        ),
        "price": json!({
            "amount": "",
            "currency": ""
        }),
        "quantity": "",
        "recipient_id": "",
        "region_code": "",
        "shipping_price": json!({
            "amount": "",
            "currency": ""
        })
    });

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

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

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

    dbg!(results);
}

echo '{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}' |  \
  http POST {{baseUrl}}/conversations/:conversation_id/offer \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "country_code": "",\n  "layaway_terms_slug": "",\n  "message": "",\n  "offer_items": [\n    {\n      "listing_id": "",\n      "price": "",\n      "shipping_price": ""\n    }\n  ],\n  "price": {\n    "amount": "",\n    "currency": ""\n  },\n  "quantity": "",\n  "recipient_id": "",\n  "region_code": "",\n  "shipping_price": {\n    "amount": "",\n    "currency": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/conversations/:conversation_id/offer

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    [
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    ]
  ],
  "price": [
    "amount": "",
    "currency": ""
  ],
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": [
    "amount": "",
    "currency": ""
  ]
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/countries"

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

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

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

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/countries HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/countries"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/countries")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/countries")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/countries');

xhr.send(data);

import axios from 'axios';

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

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/countries',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/countries',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/countries" in

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

 "{{baseUrl}}/countries",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/countries');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/countries"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/countries') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/countries

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/csps"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/csps"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/csps

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/csps/find")

require "http/client"

url = "{{baseUrl}}/csps/find"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/csps/find"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/csps/find")

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

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

import requests

url = "{{baseUrl}}/csps/find"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/csps/find"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/csps/find")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/csps/find

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/csps/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/csps/:id")

require "http/client"

url = "{{baseUrl}}/csps/:id"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/csps/:id"

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/csps/:id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/csps/:id');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/csps/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/csps/:id');

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/csps/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/csps/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/csps/:id")

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

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

import requests

url = "{{baseUrl}}/csps/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/csps/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/csps/:id")

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/csps/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/csps/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/csps/:id

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/csps/categories")

require "http/client"

url = "{{baseUrl}}/csps/categories"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/csps/categories"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/csps/categories HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/csps/categories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/csps/categories"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/csps/categories")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/csps/categories")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/csps/categories');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/csps/categories'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/csps/categories';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/csps/categories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/csps/categories")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/csps/categories',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/csps/categories'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/csps/categories');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/csps/categories'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/csps/categories';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/csps/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/csps/categories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/csps/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/csps/categories');

echo $response->getBody();

setUrl('{{baseUrl}}/csps/categories');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/csps/categories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/csps/categories' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/csps/categories' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/csps/categories")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/csps/categories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/csps/categories"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/csps/categories")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/csps/categories') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/csps/categories";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/csps/categories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/csps/categories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/csps/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/curated_sets/:slug");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/curated_sets/:slug")

require "http/client"

url = "{{baseUrl}}/curated_sets/:slug"

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}}/curated_sets/:slug"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/curated_sets/:slug");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/curated_sets/:slug"

	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/curated_sets/:slug HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/curated_sets/:slug")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/curated_sets/:slug"))
    .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}}/curated_sets/:slug")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/curated_sets/:slug")
  .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}}/curated_sets/:slug');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/curated_sets/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/curated_sets/:slug';
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}}/curated_sets/:slug',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/curated_sets/:slug")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/curated_sets/:slug',
  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}}/curated_sets/:slug'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/curated_sets/:slug');

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}}/curated_sets/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/curated_sets/:slug';
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}}/curated_sets/:slug"]
                                                       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}}/curated_sets/:slug" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/curated_sets/:slug",
  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}}/curated_sets/:slug');

echo $response->getBody();

setUrl('{{baseUrl}}/curated_sets/:slug');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/curated_sets/:slug');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/curated_sets/:slug' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/curated_sets/:slug' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/curated_sets/:slug")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/curated_sets/:slug"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/curated_sets/:slug"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/curated_sets/:slug")

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/curated_sets/:slug') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/curated_sets/:slug";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/curated_sets/:slug

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/curated_sets/:slug

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/curated_sets/:slug")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/currencies/display");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/currencies/display")

require "http/client"

url = "{{baseUrl}}/currencies/display"

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}}/currencies/display"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/currencies/display");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/currencies/display"

	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/currencies/display HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/currencies/display")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/currencies/display"))
    .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}}/currencies/display")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/currencies/display")
  .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}}/currencies/display');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/currencies/display'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/currencies/display';
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}}/currencies/display',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/currencies/display")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/currencies/display',
  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}}/currencies/display'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/currencies/display');

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}}/currencies/display'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/currencies/display';
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}}/currencies/display"]
                                                       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}}/currencies/display" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/currencies/display",
  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}}/currencies/display');

echo $response->getBody();

setUrl('{{baseUrl}}/currencies/display');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/currencies/display');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/currencies/display' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/currencies/display' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/currencies/display")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/currencies/display"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/currencies/display"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/currencies/display")

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/currencies/display') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/currencies/display";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/currencies/display

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/currencies/display

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/currencies/display")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/currencies/listing");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/currencies/listing")

require "http/client"

url = "{{baseUrl}}/currencies/listing"

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}}/currencies/listing"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/currencies/listing");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/currencies/listing"

	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/currencies/listing HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/currencies/listing")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/currencies/listing"))
    .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}}/currencies/listing")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/currencies/listing")
  .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}}/currencies/listing');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/currencies/listing'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/currencies/listing';
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}}/currencies/listing',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/currencies/listing")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/currencies/listing',
  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}}/currencies/listing'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/currencies/listing');

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}}/currencies/listing'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/currencies/listing';
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}}/currencies/listing"]
                                                       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}}/currencies/listing" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/currencies/listing",
  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}}/currencies/listing');

echo $response->getBody();

setUrl('{{baseUrl}}/currencies/listing');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/currencies/listing');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/currencies/listing' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/currencies/listing' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/currencies/listing")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/currencies/listing"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/currencies/listing"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/currencies/listing")

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/currencies/listing') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/currencies/listing";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/currencies/listing

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/currencies/listing

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/currencies/listing")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/feedback/:feedback_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/feedback/:feedback_id")

require "http/client"

url = "{{baseUrl}}/feedback/:feedback_id"

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}}/feedback/:feedback_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/feedback/:feedback_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/feedback/:feedback_id"

	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/feedback/:feedback_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/feedback/:feedback_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/feedback/:feedback_id"))
    .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}}/feedback/:feedback_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/feedback/:feedback_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/feedback/:feedback_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/feedback/:feedback_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/feedback/:feedback_id';
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}}/feedback/:feedback_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/feedback/:feedback_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/feedback/:feedback_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/feedback/:feedback_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/feedback/:feedback_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/feedback/:feedback_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/feedback/:feedback_id';
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}}/feedback/:feedback_id"]
                                                       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}}/feedback/:feedback_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/feedback/:feedback_id",
  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}}/feedback/:feedback_id');

echo $response->getBody();

setUrl('{{baseUrl}}/feedback/:feedback_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/feedback/:feedback_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/feedback/:feedback_id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/feedback/:feedback_id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/feedback/:feedback_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/feedback/:feedback_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/feedback/:feedback_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/feedback/:feedback_id")

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/feedback/:feedback_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/feedback/:feedback_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/feedback/:feedback_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/feedback/:feedback_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/feedback/:feedback_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/handpicked/:slug");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/handpicked/:slug")

require "http/client"

url = "{{baseUrl}}/handpicked/:slug"

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}}/handpicked/:slug"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/handpicked/:slug");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/handpicked/:slug"

	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/handpicked/:slug HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/handpicked/:slug")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/handpicked/:slug"))
    .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}}/handpicked/:slug")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/handpicked/:slug")
  .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}}/handpicked/:slug');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/handpicked/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/handpicked/:slug';
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}}/handpicked/:slug',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/handpicked/:slug")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/handpicked/:slug',
  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}}/handpicked/:slug'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/handpicked/:slug');

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}}/handpicked/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/handpicked/:slug';
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}}/handpicked/:slug"]
                                                       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}}/handpicked/:slug" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/handpicked/:slug",
  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}}/handpicked/:slug');

echo $response->getBody();

setUrl('{{baseUrl}}/handpicked/:slug');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/handpicked/:slug');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/handpicked/:slug' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/handpicked/:slug' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/handpicked/:slug")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/handpicked/:slug"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/handpicked/:slug"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/handpicked/:slug")

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/handpicked/:slug') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/handpicked/:slug";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/handpicked/:slug

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/handpicked/:slug

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/handpicked/:slug")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listing_conditions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listing_conditions")

require "http/client"

url = "{{baseUrl}}/listing_conditions"

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}}/listing_conditions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listing_conditions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listing_conditions"

	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/listing_conditions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listing_conditions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listing_conditions"))
    .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}}/listing_conditions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listing_conditions")
  .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}}/listing_conditions');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listing_conditions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listing_conditions';
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}}/listing_conditions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listing_conditions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listing_conditions',
  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}}/listing_conditions'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listing_conditions');

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}}/listing_conditions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listing_conditions';
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}}/listing_conditions"]
                                                       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}}/listing_conditions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listing_conditions",
  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}}/listing_conditions');

echo $response->getBody();

setUrl('{{baseUrl}}/listing_conditions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listing_conditions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listing_conditions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listing_conditions' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listing_conditions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listing_conditions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listing_conditions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listing_conditions")

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/listing_conditions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listing_conditions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listing_conditions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listing_conditions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listing_conditions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/all");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/all")

require "http/client"

url = "{{baseUrl}}/listings/all"

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}}/listings/all"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/all");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/all"

	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/listings/all HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/all")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/all"))
    .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}}/listings/all")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/all")
  .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}}/listings/all');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listings/all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/all';
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}}/listings/all',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/all")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/all',
  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}}/listings/all'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/all');

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}}/listings/all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/all';
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}}/listings/all"]
                                                       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}}/listings/all" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/all",
  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}}/listings/all');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/all');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/all');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/all' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/all' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/all")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/all"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/all"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/all")

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/listings/all') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/all";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/all

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/all

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/all")! 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}}/listings/:listing_id/bump/:budget_type");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/listings/:listing_id/bump/:budget_type")

require "http/client"

url = "{{baseUrl}}/listings/:listing_id/bump/:budget_type"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/listings/:listing_id/bump/:budget_type"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:listing_id/bump/:budget_type");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:listing_id/bump/:budget_type"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/listings/:listing_id/bump/:budget_type HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listings/:listing_id/bump/:budget_type")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:listing_id/bump/:budget_type"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/listings/:listing_id/bump/:budget_type")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/listings/:listing_id/bump/:budget_type")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/listings/:listing_id/bump/:budget_type');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings/:listing_id/bump/:budget_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:listing_id/bump/:budget_type';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/listings/:listing_id/bump/:budget_type',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:listing_id/bump/:budget_type")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:listing_id/bump/:budget_type',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings/:listing_id/bump/:budget_type'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/listings/:listing_id/bump/:budget_type');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings/:listing_id/bump/:budget_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:listing_id/bump/:budget_type';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings/:listing_id/bump/:budget_type"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/listings/:listing_id/bump/:budget_type" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:listing_id/bump/:budget_type",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/listings/:listing_id/bump/:budget_type');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:listing_id/bump/:budget_type');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:listing_id/bump/:budget_type');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:listing_id/bump/:budget_type' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:listing_id/bump/:budget_type' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/listings/:listing_id/bump/:budget_type")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:listing_id/bump/:budget_type"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:listing_id/bump/:budget_type"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:listing_id/bump/:budget_type")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/listings/:listing_id/bump/:budget_type') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:listing_id/bump/:budget_type";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/listings/:listing_id/bump/:budget_type

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/listings/:listing_id/bump/:budget_type

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:listing_id/bump/:budget_type")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/listings" {:content-type :json
                                                     :form-params {:categories [{:uuid ""}]
                                                                   :condition {:uuid ""}
                                                                   :description ""
                                                                   :exclusive_channel ""
                                                                   :finish ""
                                                                   :has_inventory false
                                                                   :inventory 0
                                                                   :location {:country_code ""
                                                                              :locality ""
                                                                              :region ""}
                                                                   :make ""
                                                                   :model ""
                                                                   :multi_item false
                                                                   :offers_enabled false
                                                                   :origin_country_code ""
                                                                   :photos []
                                                                   :preorder_info {:lead_time 0
                                                                                   :lead_time_unit ""
                                                                                   :ship_date ""}
                                                                   :price {:amount ""
                                                                           :currency ""}
                                                                   :prop_65_warning ""
                                                                   :publish false
                                                                   :seller {:paypal_email ""}
                                                                   :seller_cost ""
                                                                   :shipping {:local false
                                                                              :rates [{:rate {:amount ""
                                                                                              :currency ""}
                                                                                       :region_code ""}]}
                                                                   :shipping_profile_id ""
                                                                   :shipping_profile_name ""
                                                                   :sku ""
                                                                   :sold_as_is false
                                                                   :storage_location ""
                                                                   :tax_exempt false
                                                                   :title ""
                                                                   :upc ""
                                                                   :upc_does_not_apply false
                                                                   :videos [{:link ""}]
                                                                   :year ""}})

require "http/client"

url = "{{baseUrl}}/listings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\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}}/listings"),
    Content = new StringContent("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\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}}/listings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings"

	payload := strings.NewReader("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/listings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1108

{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\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  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/listings")
  .header("content-type", "application/json")
  .body("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  categories: [
    {
      uuid: ''
    }
  ],
  condition: {
    uuid: ''
  },
  description: '',
  exclusive_channel: '',
  finish: '',
  has_inventory: false,
  inventory: 0,
  location: {
    country_code: '',
    locality: '',
    region: ''
  },
  make: '',
  model: '',
  multi_item: false,
  offers_enabled: false,
  origin_country_code: '',
  photos: [],
  preorder_info: {
    lead_time: 0,
    lead_time_unit: '',
    ship_date: ''
  },
  price: {
    amount: '',
    currency: ''
  },
  prop_65_warning: '',
  publish: false,
  seller: {
    paypal_email: ''
  },
  seller_cost: '',
  shipping: {
    local: false,
    rates: [
      {
        rate: {
          amount: '',
          currency: ''
        },
        region_code: ''
      }
    ]
  },
  shipping_profile_id: '',
  shipping_profile_name: '',
  sku: '',
  sold_as_is: false,
  storage_location: '',
  tax_exempt: false,
  title: '',
  upc: '',
  upc_does_not_apply: false,
  videos: [
    {
      link: ''
    }
  ],
  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}}/listings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings',
  headers: {'content-type': 'application/json'},
  data: {
    categories: [{uuid: ''}],
    condition: {uuid: ''},
    description: '',
    exclusive_channel: '',
    finish: '',
    has_inventory: false,
    inventory: 0,
    location: {country_code: '', locality: '', region: ''},
    make: '',
    model: '',
    multi_item: false,
    offers_enabled: false,
    origin_country_code: '',
    photos: [],
    preorder_info: {lead_time: 0, lead_time_unit: '', ship_date: ''},
    price: {amount: '', currency: ''},
    prop_65_warning: '',
    publish: false,
    seller: {paypal_email: ''},
    seller_cost: '',
    shipping: {local: false, rates: [{rate: {amount: '', currency: ''}, region_code: ''}]},
    shipping_profile_id: '',
    shipping_profile_name: '',
    sku: '',
    sold_as_is: false,
    storage_location: '',
    tax_exempt: false,
    title: '',
    upc: '',
    upc_does_not_apply: false,
    videos: [{link: ''}],
    year: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[{"uuid":""}],"condition":{"uuid":""},"description":"","exclusive_channel":"","finish":"","has_inventory":false,"inventory":0,"location":{"country_code":"","locality":"","region":""},"make":"","model":"","multi_item":false,"offers_enabled":false,"origin_country_code":"","photos":[],"preorder_info":{"lead_time":0,"lead_time_unit":"","ship_date":""},"price":{"amount":"","currency":""},"prop_65_warning":"","publish":false,"seller":{"paypal_email":""},"seller_cost":"","shipping":{"local":false,"rates":[{"rate":{"amount":"","currency":""},"region_code":""}]},"shipping_profile_id":"","shipping_profile_name":"","sku":"","sold_as_is":false,"storage_location":"","tax_exempt":false,"title":"","upc":"","upc_does_not_apply":false,"videos":[{"link":""}],"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}}/listings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "categories": [\n    {\n      "uuid": ""\n    }\n  ],\n  "condition": {\n    "uuid": ""\n  },\n  "description": "",\n  "exclusive_channel": "",\n  "finish": "",\n  "has_inventory": false,\n  "inventory": 0,\n  "location": {\n    "country_code": "",\n    "locality": "",\n    "region": ""\n  },\n  "make": "",\n  "model": "",\n  "multi_item": false,\n  "offers_enabled": false,\n  "origin_country_code": "",\n  "photos": [],\n  "preorder_info": {\n    "lead_time": 0,\n    "lead_time_unit": "",\n    "ship_date": ""\n  },\n  "price": {\n    "amount": "",\n    "currency": ""\n  },\n  "prop_65_warning": "",\n  "publish": false,\n  "seller": {\n    "paypal_email": ""\n  },\n  "seller_cost": "",\n  "shipping": {\n    "local": false,\n    "rates": [\n      {\n        "rate": {\n          "amount": "",\n          "currency": ""\n        },\n        "region_code": ""\n      }\n    ]\n  },\n  "shipping_profile_id": "",\n  "shipping_profile_name": "",\n  "sku": "",\n  "sold_as_is": false,\n  "storage_location": "",\n  "tax_exempt": false,\n  "title": "",\n  "upc": "",\n  "upc_does_not_apply": false,\n  "videos": [\n    {\n      "link": ""\n    }\n  ],\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  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  categories: [{uuid: ''}],
  condition: {uuid: ''},
  description: '',
  exclusive_channel: '',
  finish: '',
  has_inventory: false,
  inventory: 0,
  location: {country_code: '', locality: '', region: ''},
  make: '',
  model: '',
  multi_item: false,
  offers_enabled: false,
  origin_country_code: '',
  photos: [],
  preorder_info: {lead_time: 0, lead_time_unit: '', ship_date: ''},
  price: {amount: '', currency: ''},
  prop_65_warning: '',
  publish: false,
  seller: {paypal_email: ''},
  seller_cost: '',
  shipping: {local: false, rates: [{rate: {amount: '', currency: ''}, region_code: ''}]},
  shipping_profile_id: '',
  shipping_profile_name: '',
  sku: '',
  sold_as_is: false,
  storage_location: '',
  tax_exempt: false,
  title: '',
  upc: '',
  upc_does_not_apply: false,
  videos: [{link: ''}],
  year: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings',
  headers: {'content-type': 'application/json'},
  body: {
    categories: [{uuid: ''}],
    condition: {uuid: ''},
    description: '',
    exclusive_channel: '',
    finish: '',
    has_inventory: false,
    inventory: 0,
    location: {country_code: '', locality: '', region: ''},
    make: '',
    model: '',
    multi_item: false,
    offers_enabled: false,
    origin_country_code: '',
    photos: [],
    preorder_info: {lead_time: 0, lead_time_unit: '', ship_date: ''},
    price: {amount: '', currency: ''},
    prop_65_warning: '',
    publish: false,
    seller: {paypal_email: ''},
    seller_cost: '',
    shipping: {local: false, rates: [{rate: {amount: '', currency: ''}, region_code: ''}]},
    shipping_profile_id: '',
    shipping_profile_name: '',
    sku: '',
    sold_as_is: false,
    storage_location: '',
    tax_exempt: false,
    title: '',
    upc: '',
    upc_does_not_apply: false,
    videos: [{link: ''}],
    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}}/listings');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  categories: [
    {
      uuid: ''
    }
  ],
  condition: {
    uuid: ''
  },
  description: '',
  exclusive_channel: '',
  finish: '',
  has_inventory: false,
  inventory: 0,
  location: {
    country_code: '',
    locality: '',
    region: ''
  },
  make: '',
  model: '',
  multi_item: false,
  offers_enabled: false,
  origin_country_code: '',
  photos: [],
  preorder_info: {
    lead_time: 0,
    lead_time_unit: '',
    ship_date: ''
  },
  price: {
    amount: '',
    currency: ''
  },
  prop_65_warning: '',
  publish: false,
  seller: {
    paypal_email: ''
  },
  seller_cost: '',
  shipping: {
    local: false,
    rates: [
      {
        rate: {
          amount: '',
          currency: ''
        },
        region_code: ''
      }
    ]
  },
  shipping_profile_id: '',
  shipping_profile_name: '',
  sku: '',
  sold_as_is: false,
  storage_location: '',
  tax_exempt: false,
  title: '',
  upc: '',
  upc_does_not_apply: false,
  videos: [
    {
      link: ''
    }
  ],
  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}}/listings',
  headers: {'content-type': 'application/json'},
  data: {
    categories: [{uuid: ''}],
    condition: {uuid: ''},
    description: '',
    exclusive_channel: '',
    finish: '',
    has_inventory: false,
    inventory: 0,
    location: {country_code: '', locality: '', region: ''},
    make: '',
    model: '',
    multi_item: false,
    offers_enabled: false,
    origin_country_code: '',
    photos: [],
    preorder_info: {lead_time: 0, lead_time_unit: '', ship_date: ''},
    price: {amount: '', currency: ''},
    prop_65_warning: '',
    publish: false,
    seller: {paypal_email: ''},
    seller_cost: '',
    shipping: {local: false, rates: [{rate: {amount: '', currency: ''}, region_code: ''}]},
    shipping_profile_id: '',
    shipping_profile_name: '',
    sku: '',
    sold_as_is: false,
    storage_location: '',
    tax_exempt: false,
    title: '',
    upc: '',
    upc_does_not_apply: false,
    videos: [{link: ''}],
    year: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[{"uuid":""}],"condition":{"uuid":""},"description":"","exclusive_channel":"","finish":"","has_inventory":false,"inventory":0,"location":{"country_code":"","locality":"","region":""},"make":"","model":"","multi_item":false,"offers_enabled":false,"origin_country_code":"","photos":[],"preorder_info":{"lead_time":0,"lead_time_unit":"","ship_date":""},"price":{"amount":"","currency":""},"prop_65_warning":"","publish":false,"seller":{"paypal_email":""},"seller_cost":"","shipping":{"local":false,"rates":[{"rate":{"amount":"","currency":""},"region_code":""}]},"shipping_profile_id":"","shipping_profile_name":"","sku":"","sold_as_is":false,"storage_location":"","tax_exempt":false,"title":"","upc":"","upc_does_not_apply":false,"videos":[{"link":""}],"year":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"categories": @[ @{ @"uuid": @"" } ],
                              @"condition": @{ @"uuid": @"" },
                              @"description": @"",
                              @"exclusive_channel": @"",
                              @"finish": @"",
                              @"has_inventory": @NO,
                              @"inventory": @0,
                              @"location": @{ @"country_code": @"", @"locality": @"", @"region": @"" },
                              @"make": @"",
                              @"model": @"",
                              @"multi_item": @NO,
                              @"offers_enabled": @NO,
                              @"origin_country_code": @"",
                              @"photos": @[  ],
                              @"preorder_info": @{ @"lead_time": @0, @"lead_time_unit": @"", @"ship_date": @"" },
                              @"price": @{ @"amount": @"", @"currency": @"" },
                              @"prop_65_warning": @"",
                              @"publish": @NO,
                              @"seller": @{ @"paypal_email": @"" },
                              @"seller_cost": @"",
                              @"shipping": @{ @"local": @NO, @"rates": @[ @{ @"rate": @{ @"amount": @"", @"currency": @"" }, @"region_code": @"" } ] },
                              @"shipping_profile_id": @"",
                              @"shipping_profile_name": @"",
                              @"sku": @"",
                              @"sold_as_is": @NO,
                              @"storage_location": @"",
                              @"tax_exempt": @NO,
                              @"title": @"",
                              @"upc": @"",
                              @"upc_does_not_apply": @NO,
                              @"videos": @[ @{ @"link": @"" } ],
                              @"year": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings"]
                                                       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}}/listings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings",
  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([
    'categories' => [
        [
                'uuid' => ''
        ]
    ],
    'condition' => [
        'uuid' => ''
    ],
    'description' => '',
    'exclusive_channel' => '',
    'finish' => '',
    'has_inventory' => null,
    'inventory' => 0,
    'location' => [
        'country_code' => '',
        'locality' => '',
        'region' => ''
    ],
    'make' => '',
    'model' => '',
    'multi_item' => null,
    'offers_enabled' => null,
    'origin_country_code' => '',
    'photos' => [
        
    ],
    'preorder_info' => [
        'lead_time' => 0,
        'lead_time_unit' => '',
        'ship_date' => ''
    ],
    'price' => [
        'amount' => '',
        'currency' => ''
    ],
    'prop_65_warning' => '',
    'publish' => null,
    'seller' => [
        'paypal_email' => ''
    ],
    'seller_cost' => '',
    'shipping' => [
        'local' => null,
        'rates' => [
                [
                                'rate' => [
                                                                'amount' => '',
                                                                'currency' => ''
                                ],
                                'region_code' => ''
                ]
        ]
    ],
    'shipping_profile_id' => '',
    'shipping_profile_name' => '',
    'sku' => '',
    'sold_as_is' => null,
    'storage_location' => '',
    'tax_exempt' => null,
    'title' => '',
    'upc' => '',
    'upc_does_not_apply' => null,
    'videos' => [
        [
                'link' => ''
        ]
    ],
    'year' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/listings', [
  'body' => '{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'categories' => [
    [
        'uuid' => ''
    ]
  ],
  'condition' => [
    'uuid' => ''
  ],
  'description' => '',
  'exclusive_channel' => '',
  'finish' => '',
  'has_inventory' => null,
  'inventory' => 0,
  'location' => [
    'country_code' => '',
    'locality' => '',
    'region' => ''
  ],
  'make' => '',
  'model' => '',
  'multi_item' => null,
  'offers_enabled' => null,
  'origin_country_code' => '',
  'photos' => [
    
  ],
  'preorder_info' => [
    'lead_time' => 0,
    'lead_time_unit' => '',
    'ship_date' => ''
  ],
  'price' => [
    'amount' => '',
    'currency' => ''
  ],
  'prop_65_warning' => '',
  'publish' => null,
  'seller' => [
    'paypal_email' => ''
  ],
  'seller_cost' => '',
  'shipping' => [
    'local' => null,
    'rates' => [
        [
                'rate' => [
                                'amount' => '',
                                'currency' => ''
                ],
                'region_code' => ''
        ]
    ]
  ],
  'shipping_profile_id' => '',
  'shipping_profile_name' => '',
  'sku' => '',
  'sold_as_is' => null,
  'storage_location' => '',
  'tax_exempt' => null,
  'title' => '',
  'upc' => '',
  'upc_does_not_apply' => null,
  'videos' => [
    [
        'link' => ''
    ]
  ],
  'year' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'categories' => [
    [
        'uuid' => ''
    ]
  ],
  'condition' => [
    'uuid' => ''
  ],
  'description' => '',
  'exclusive_channel' => '',
  'finish' => '',
  'has_inventory' => null,
  'inventory' => 0,
  'location' => [
    'country_code' => '',
    'locality' => '',
    'region' => ''
  ],
  'make' => '',
  'model' => '',
  'multi_item' => null,
  'offers_enabled' => null,
  'origin_country_code' => '',
  'photos' => [
    
  ],
  'preorder_info' => [
    'lead_time' => 0,
    'lead_time_unit' => '',
    'ship_date' => ''
  ],
  'price' => [
    'amount' => '',
    'currency' => ''
  ],
  'prop_65_warning' => '',
  'publish' => null,
  'seller' => [
    'paypal_email' => ''
  ],
  'seller_cost' => '',
  'shipping' => [
    'local' => null,
    'rates' => [
        [
                'rate' => [
                                'amount' => '',
                                'currency' => ''
                ],
                'region_code' => ''
        ]
    ]
  ],
  'shipping_profile_id' => '',
  'shipping_profile_name' => '',
  'sku' => '',
  'sold_as_is' => null,
  'storage_location' => '',
  'tax_exempt' => null,
  'title' => '',
  'upc' => '',
  'upc_does_not_apply' => null,
  'videos' => [
    [
        'link' => ''
    ]
  ],
  'year' => ''
]));
$request->setRequestUrl('{{baseUrl}}/listings');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/listings", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings"

payload = {
    "categories": [{ "uuid": "" }],
    "condition": { "uuid": "" },
    "description": "",
    "exclusive_channel": "",
    "finish": "",
    "has_inventory": False,
    "inventory": 0,
    "location": {
        "country_code": "",
        "locality": "",
        "region": ""
    },
    "make": "",
    "model": "",
    "multi_item": False,
    "offers_enabled": False,
    "origin_country_code": "",
    "photos": [],
    "preorder_info": {
        "lead_time": 0,
        "lead_time_unit": "",
        "ship_date": ""
    },
    "price": {
        "amount": "",
        "currency": ""
    },
    "prop_65_warning": "",
    "publish": False,
    "seller": { "paypal_email": "" },
    "seller_cost": "",
    "shipping": {
        "local": False,
        "rates": [
            {
                "rate": {
                    "amount": "",
                    "currency": ""
                },
                "region_code": ""
            }
        ]
    },
    "shipping_profile_id": "",
    "shipping_profile_name": "",
    "sku": "",
    "sold_as_is": False,
    "storage_location": "",
    "tax_exempt": False,
    "title": "",
    "upc": "",
    "upc_does_not_apply": False,
    "videos": [{ "link": "" }],
    "year": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings"

payload <- "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\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/listings') do |req|
  req.body = "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\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}}/listings";

    let payload = json!({
        "categories": (json!({"uuid": ""})),
        "condition": json!({"uuid": ""}),
        "description": "",
        "exclusive_channel": "",
        "finish": "",
        "has_inventory": false,
        "inventory": 0,
        "location": json!({
            "country_code": "",
            "locality": "",
            "region": ""
        }),
        "make": "",
        "model": "",
        "multi_item": false,
        "offers_enabled": false,
        "origin_country_code": "",
        "photos": (),
        "preorder_info": json!({
            "lead_time": 0,
            "lead_time_unit": "",
            "ship_date": ""
        }),
        "price": json!({
            "amount": "",
            "currency": ""
        }),
        "prop_65_warning": "",
        "publish": false,
        "seller": json!({"paypal_email": ""}),
        "seller_cost": "",
        "shipping": json!({
            "local": false,
            "rates": (
                json!({
                    "rate": json!({
                        "amount": "",
                        "currency": ""
                    }),
                    "region_code": ""
                })
            )
        }),
        "shipping_profile_id": "",
        "shipping_profile_name": "",
        "sku": "",
        "sold_as_is": false,
        "storage_location": "",
        "tax_exempt": false,
        "title": "",
        "upc": "",
        "upc_does_not_apply": false,
        "videos": (json!({"link": ""})),
        "year": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}' |  \
  http POST {{baseUrl}}/listings \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "categories": [\n    {\n      "uuid": ""\n    }\n  ],\n  "condition": {\n    "uuid": ""\n  },\n  "description": "",\n  "exclusive_channel": "",\n  "finish": "",\n  "has_inventory": false,\n  "inventory": 0,\n  "location": {\n    "country_code": "",\n    "locality": "",\n    "region": ""\n  },\n  "make": "",\n  "model": "",\n  "multi_item": false,\n  "offers_enabled": false,\n  "origin_country_code": "",\n  "photos": [],\n  "preorder_info": {\n    "lead_time": 0,\n    "lead_time_unit": "",\n    "ship_date": ""\n  },\n  "price": {\n    "amount": "",\n    "currency": ""\n  },\n  "prop_65_warning": "",\n  "publish": false,\n  "seller": {\n    "paypal_email": ""\n  },\n  "seller_cost": "",\n  "shipping": {\n    "local": false,\n    "rates": [\n      {\n        "rate": {\n          "amount": "",\n          "currency": ""\n        },\n        "region_code": ""\n      }\n    ]\n  },\n  "shipping_profile_id": "",\n  "shipping_profile_name": "",\n  "sku": "",\n  "sold_as_is": false,\n  "storage_location": "",\n  "tax_exempt": false,\n  "title": "",\n  "upc": "",\n  "upc_does_not_apply": false,\n  "videos": [\n    {\n      "link": ""\n    }\n  ],\n  "year": ""\n}' \
  --output-document \
  - {{baseUrl}}/listings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "categories": [["uuid": ""]],
  "condition": ["uuid": ""],
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": [
    "country_code": "",
    "locality": "",
    "region": ""
  ],
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": [
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  ],
  "price": [
    "amount": "",
    "currency": ""
  ],
  "prop_65_warning": "",
  "publish": false,
  "seller": ["paypal_email": ""],
  "seller_cost": "",
  "shipping": [
    "local": false,
    "rates": [
      [
        "rate": [
          "amount": "",
          "currency": ""
        ],
        "region_code": ""
      ]
    ]
  ],
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [["link": ""]],
  "year": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings")! 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}}/listings/:slug/reviews");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/listings/:slug/reviews")

require "http/client"

url = "{{baseUrl}}/listings/:slug/reviews"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/listings/:slug/reviews"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:slug/reviews");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:slug/reviews"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/listings/:slug/reviews HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listings/:slug/reviews")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:slug/reviews"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/listings/:slug/reviews")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/listings/:slug/reviews")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/listings/:slug/reviews');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/listings/:slug/reviews'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:slug/reviews';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/listings/:slug/reviews',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:slug/reviews")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:slug/reviews',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/listings/:slug/reviews'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/listings/:slug/reviews');

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}}/listings/:slug/reviews'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:slug/reviews';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings/:slug/reviews"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/listings/:slug/reviews" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:slug/reviews",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/listings/:slug/reviews');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:slug/reviews');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:slug/reviews');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:slug/reviews' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:slug/reviews' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/listings/:slug/reviews")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:slug/reviews"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:slug/reviews"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:slug/reviews")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/listings/:slug/reviews') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:slug/reviews";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/listings/:slug/reviews

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/listings/:slug/reviews

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:slug/reviews")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings")

require "http/client"

url = "{{baseUrl}}/listings"

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}}/listings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings"

	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/listings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings"))
    .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}}/listings")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings")
  .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}}/listings');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listings'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings';
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}}/listings',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings',
  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}}/listings'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings');

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}}/listings'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings';
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}}/listings"]
                                                       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}}/listings" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings",
  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}}/listings');

echo $response->getBody();

setUrl('{{baseUrl}}/listings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings")

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/listings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:slug");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/listings/:slug")

require "http/client"

url = "{{baseUrl}}/listings/:slug"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/listings/:slug"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:slug");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:slug"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/listings/:slug HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/listings/:slug")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:slug"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/listings/:slug")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/listings/:slug")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/listings/:slug');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/listings/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:slug';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/listings/:slug',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:slug")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:slug',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/listings/:slug'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/listings/:slug');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/listings/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:slug';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings/:slug"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/listings/:slug" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:slug",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/listings/:slug');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:slug');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:slug');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:slug' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:slug' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/listings/:slug")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:slug"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:slug"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:slug")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/listings/:slug') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:slug";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/listings/:slug

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/listings/:slug

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:slug")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:listing_id/images/:image_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/listings/:listing_id/images/:image_id")

require "http/client"

url = "{{baseUrl}}/listings/:listing_id/images/:image_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/listings/:listing_id/images/:image_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:listing_id/images/:image_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:listing_id/images/:image_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/listings/:listing_id/images/:image_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/listings/:listing_id/images/:image_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:listing_id/images/:image_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/listings/:listing_id/images/:image_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/listings/:listing_id/images/:image_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/listings/:listing_id/images/:image_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/listings/:listing_id/images/:image_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:listing_id/images/:image_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/listings/:listing_id/images/:image_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:listing_id/images/:image_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:listing_id/images/:image_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/listings/:listing_id/images/:image_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/listings/:listing_id/images/:image_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/listings/:listing_id/images/:image_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:listing_id/images/:image_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings/:listing_id/images/:image_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/listings/:listing_id/images/:image_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:listing_id/images/:image_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/listings/:listing_id/images/:image_id');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:listing_id/images/:image_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:listing_id/images/:image_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:listing_id/images/:image_id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:listing_id/images/:image_id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/listings/:listing_id/images/:image_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:listing_id/images/:image_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:listing_id/images/:image_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:listing_id/images/:image_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/listings/:listing_id/images/:image_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:listing_id/images/:image_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/listings/:listing_id/images/:image_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/listings/:listing_id/images/:image_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:listing_id/images/:image_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:slug/edit");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/:slug/edit")

require "http/client"

url = "{{baseUrl}}/listings/:slug/edit"

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}}/listings/:slug/edit"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:slug/edit");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:slug/edit"

	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/listings/:slug/edit HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/:slug/edit")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:slug/edit"))
    .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}}/listings/:slug/edit")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/:slug/edit")
  .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}}/listings/:slug/edit');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listings/:slug/edit'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:slug/edit';
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}}/listings/:slug/edit',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:slug/edit")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:slug/edit',
  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}}/listings/:slug/edit'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/:slug/edit');

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}}/listings/:slug/edit'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:slug/edit';
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}}/listings/:slug/edit"]
                                                       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}}/listings/:slug/edit" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:slug/edit",
  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}}/listings/:slug/edit');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:slug/edit');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:slug/edit');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:slug/edit' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:slug/edit' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/:slug/edit")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:slug/edit"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:slug/edit"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:slug/edit")

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/listings/:slug/edit') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:slug/edit";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/:slug/edit

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/:slug/edit

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:slug/edit")! 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}}/listings/:slug/flag");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"reason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/listings/:slug/flag" {:content-type :json
                                                                :form-params {:description ""
                                                                              :reason ""}})

require "http/client"

url = "{{baseUrl}}/listings/:slug/flag"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"reason\": \"\"\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}}/listings/:slug/flag"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"reason\": \"\"\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}}/listings/:slug/flag");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:slug/flag"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"reason\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/listings/:slug/flag HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "description": "",
  "reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listings/:slug/flag")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:slug/flag"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"reason\": \"\"\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  \"description\": \"\",\n  \"reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listings/:slug/flag")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/listings/:slug/flag")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  reason: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/listings/:slug/flag');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings/:slug/flag',
  headers: {'content-type': 'application/json'},
  data: {description: '', reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:slug/flag';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","reason":""}'
};

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}}/listings/:slug/flag',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "reason": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listings/:slug/flag")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:slug/flag',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({description: '', reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings/:slug/flag',
  headers: {'content-type': 'application/json'},
  body: {description: '', reason: ''},
  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}}/listings/:slug/flag');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  reason: ''
});

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}}/listings/:slug/flag',
  headers: {'content-type': 'application/json'},
  data: {description: '', reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:slug/flag';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"reason": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings/:slug/flag"]
                                                       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}}/listings/:slug/flag" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"reason\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:slug/flag",
  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([
    'description' => '',
    'reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/listings/:slug/flag', [
  'body' => '{
  "description": "",
  "reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:slug/flag');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'reason' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/listings/:slug/flag');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:slug/flag' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "reason": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:slug/flag' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "reason": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"reason\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/listings/:slug/flag", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:slug/flag"

payload = {
    "description": "",
    "reason": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:slug/flag"

payload <- "{\n  \"description\": \"\",\n  \"reason\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:slug/flag")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"description\": \"\",\n  \"reason\": \"\"\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/listings/:slug/flag') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"reason\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:slug/flag";

    let payload = json!({
        "description": "",
        "reason": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "description": "",
  "reason": ""
}' |  \
  http POST {{baseUrl}}/listings/:slug/flag \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "reason": ""\n}' \
  --output-document \
  - {{baseUrl}}/listings/:slug/flag

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "reason": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:slug/flag")! 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}}/listings/facets/seller_location");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/facets/seller_location")

require "http/client"

url = "{{baseUrl}}/listings/facets/seller_location"

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}}/listings/facets/seller_location"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/facets/seller_location");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/facets/seller_location"

	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/listings/facets/seller_location HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/facets/seller_location")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/facets/seller_location"))
    .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}}/listings/facets/seller_location")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/facets/seller_location")
  .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}}/listings/facets/seller_location');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/listings/facets/seller_location'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/facets/seller_location';
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}}/listings/facets/seller_location',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/facets/seller_location")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/facets/seller_location',
  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}}/listings/facets/seller_location'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/facets/seller_location');

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}}/listings/facets/seller_location'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/facets/seller_location';
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}}/listings/facets/seller_location"]
                                                       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}}/listings/facets/seller_location" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/facets/seller_location",
  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}}/listings/facets/seller_location');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/facets/seller_location');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/facets/seller_location');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/facets/seller_location' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/facets/seller_location' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/facets/seller_location")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/facets/seller_location"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/facets/seller_location"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/facets/seller_location")

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/listings/facets/seller_location') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/facets/seller_location";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/facets/seller_location

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/facets/seller_location

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/facets/seller_location")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:slug/similar_listings");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/:slug/similar_listings")

require "http/client"

url = "{{baseUrl}}/listings/:slug/similar_listings"

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}}/listings/:slug/similar_listings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:slug/similar_listings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:slug/similar_listings"

	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/listings/:slug/similar_listings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/:slug/similar_listings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:slug/similar_listings"))
    .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}}/listings/:slug/similar_listings")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/:slug/similar_listings")
  .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}}/listings/:slug/similar_listings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/listings/:slug/similar_listings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:slug/similar_listings';
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}}/listings/:slug/similar_listings',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:slug/similar_listings")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:slug/similar_listings',
  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}}/listings/:slug/similar_listings'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/:slug/similar_listings');

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}}/listings/:slug/similar_listings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:slug/similar_listings';
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}}/listings/:slug/similar_listings"]
                                                       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}}/listings/:slug/similar_listings" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:slug/similar_listings",
  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}}/listings/:slug/similar_listings');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:slug/similar_listings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:slug/similar_listings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:slug/similar_listings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:slug/similar_listings' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/:slug/similar_listings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:slug/similar_listings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:slug/similar_listings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:slug/similar_listings")

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/listings/:slug/similar_listings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:slug/similar_listings";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/:slug/similar_listings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/:slug/similar_listings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:slug/similar_listings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:slug");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/:slug")

require "http/client"

url = "{{baseUrl}}/listings/:slug"

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}}/listings/:slug"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:slug");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:slug"

	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/listings/:slug HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/:slug")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:slug"))
    .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}}/listings/:slug")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/:slug")
  .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}}/listings/:slug');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listings/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:slug';
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}}/listings/:slug',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:slug")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:slug',
  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}}/listings/:slug'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/:slug');

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}}/listings/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:slug';
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}}/listings/:slug"]
                                                       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}}/listings/:slug" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:slug",
  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}}/listings/:slug');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:slug');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:slug');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:slug' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:slug' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/:slug")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:slug"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:slug"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:slug")

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/listings/:slug') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:slug";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/:slug

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/:slug

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:slug")! 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}}/listings/:id/offer");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/listings/:id/offer" {:content-type :json
                                                               :form-params {:message ""
                                                                             :price ""
                                                                             :shipping_price ""}})

require "http/client"

url = "{{baseUrl}}/listings/:id/offer"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\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}}/listings/:id/offer"),
    Content = new StringContent("{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\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}}/listings/:id/offer");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:id/offer"

	payload := strings.NewReader("{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/listings/:id/offer HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "message": "",
  "price": "",
  "shipping_price": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listings/:id/offer")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:id/offer"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\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  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listings/:id/offer")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/listings/:id/offer")
  .header("content-type", "application/json")
  .body("{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  message: '',
  price: '',
  shipping_price: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/listings/:id/offer');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings/:id/offer',
  headers: {'content-type': 'application/json'},
  data: {message: '', price: '', shipping_price: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:id/offer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"message":"","price":"","shipping_price":""}'
};

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}}/listings/:id/offer',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "message": "",\n  "price": "",\n  "shipping_price": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listings/:id/offer")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:id/offer',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({message: '', price: '', shipping_price: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings/:id/offer',
  headers: {'content-type': 'application/json'},
  body: {message: '', price: '', shipping_price: ''},
  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}}/listings/:id/offer');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  message: '',
  price: '',
  shipping_price: ''
});

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}}/listings/:id/offer',
  headers: {'content-type': 'application/json'},
  data: {message: '', price: '', shipping_price: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:id/offer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"message":"","price":"","shipping_price":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"message": @"",
                              @"price": @"",
                              @"shipping_price": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings/:id/offer"]
                                                       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}}/listings/:id/offer" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:id/offer",
  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([
    'message' => '',
    'price' => '',
    'shipping_price' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/listings/:id/offer', [
  'body' => '{
  "message": "",
  "price": "",
  "shipping_price": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:id/offer');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'message' => '',
  'price' => '',
  'shipping_price' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'message' => '',
  'price' => '',
  'shipping_price' => ''
]));
$request->setRequestUrl('{{baseUrl}}/listings/:id/offer');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:id/offer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": "",
  "price": "",
  "shipping_price": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:id/offer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": "",
  "price": "",
  "shipping_price": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/listings/:id/offer", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:id/offer"

payload = {
    "message": "",
    "price": "",
    "shipping_price": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:id/offer"

payload <- "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:id/offer")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\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/listings/:id/offer') do |req|
  req.body = "{\n  \"message\": \"\",\n  \"price\": \"\",\n  \"shipping_price\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:id/offer";

    let payload = json!({
        "message": "",
        "price": "",
        "shipping_price": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "message": "",
  "price": "",
  "shipping_price": ""
}' |  \
  http POST {{baseUrl}}/listings/:id/offer \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "message": "",\n  "price": "",\n  "shipping_price": ""\n}' \
  --output-document \
  - {{baseUrl}}/listings/:id/offer

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "message": "",
  "price": "",
  "shipping_price": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:id/offer")! 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}}/listings/:id/negotiation");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/:id/negotiation")

require "http/client"

url = "{{baseUrl}}/listings/:id/negotiation"

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}}/listings/:id/negotiation"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:id/negotiation");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:id/negotiation"

	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/listings/:id/negotiation HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/:id/negotiation")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:id/negotiation"))
    .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}}/listings/:id/negotiation")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/:id/negotiation")
  .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}}/listings/:id/negotiation');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listings/:id/negotiation'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:id/negotiation';
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}}/listings/:id/negotiation',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:id/negotiation")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:id/negotiation',
  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}}/listings/:id/negotiation'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/:id/negotiation');

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}}/listings/:id/negotiation'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:id/negotiation';
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}}/listings/:id/negotiation"]
                                                       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}}/listings/:id/negotiation" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:id/negotiation",
  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}}/listings/:id/negotiation');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:id/negotiation');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:id/negotiation');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:id/negotiation' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:id/negotiation' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/:id/negotiation")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:id/negotiation"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:id/negotiation"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:id/negotiation")

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/listings/:id/negotiation') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:id/negotiation";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/:id/negotiation

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/:id/negotiation

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:id/negotiation")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:listing_id/sales");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/:listing_id/sales")

require "http/client"

url = "{{baseUrl}}/listings/:listing_id/sales"

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}}/listings/:listing_id/sales"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:listing_id/sales");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:listing_id/sales"

	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/listings/:listing_id/sales HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/:listing_id/sales")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:listing_id/sales"))
    .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}}/listings/:listing_id/sales")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/:listing_id/sales")
  .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}}/listings/:listing_id/sales');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listings/:listing_id/sales'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:listing_id/sales';
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}}/listings/:listing_id/sales',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:listing_id/sales")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:listing_id/sales',
  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}}/listings/:listing_id/sales'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/:listing_id/sales');

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}}/listings/:listing_id/sales'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:listing_id/sales';
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}}/listings/:listing_id/sales"]
                                                       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}}/listings/:listing_id/sales" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:listing_id/sales",
  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}}/listings/:listing_id/sales');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:listing_id/sales');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:listing_id/sales');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:listing_id/sales' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:listing_id/sales' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/:listing_id/sales")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:listing_id/sales"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:listing_id/sales"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:listing_id/sales")

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/listings/:listing_id/sales') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:listing_id/sales";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/:listing_id/sales

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/:listing_id/sales

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:listing_id/sales")! 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}}/listings/:listing_id/conversations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"body\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/listings/:listing_id/conversations" {:content-type :json
                                                                               :form-params {:body ""}})

require "http/client"

url = "{{baseUrl}}/listings/:listing_id/conversations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"body\": \"\"\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}}/listings/:listing_id/conversations"),
    Content = new StringContent("{\n  \"body\": \"\"\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}}/listings/:listing_id/conversations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"body\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:listing_id/conversations"

	payload := strings.NewReader("{\n  \"body\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/listings/:listing_id/conversations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "body": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listings/:listing_id/conversations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"body\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:listing_id/conversations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"body\": \"\"\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  \"body\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listings/:listing_id/conversations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/listings/:listing_id/conversations")
  .header("content-type", "application/json")
  .body("{\n  \"body\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  body: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/listings/:listing_id/conversations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings/:listing_id/conversations',
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:listing_id/conversations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"body":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/listings/:listing_id/conversations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "body": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"body\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listings/:listing_id/conversations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:listing_id/conversations',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({body: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listings/:listing_id/conversations',
  headers: {'content-type': 'application/json'},
  body: {body: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/listings/:listing_id/conversations');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  body: ''
});

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}}/listings/:listing_id/conversations',
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:listing_id/conversations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"body":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"body": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings/:listing_id/conversations"]
                                                       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}}/listings/:listing_id/conversations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"body\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:listing_id/conversations",
  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([
    'body' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/listings/:listing_id/conversations', [
  'body' => '{
  "body": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:listing_id/conversations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'body' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'body' => ''
]));
$request->setRequestUrl('{{baseUrl}}/listings/:listing_id/conversations');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:listing_id/conversations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:listing_id/conversations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"body\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/listings/:listing_id/conversations", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:listing_id/conversations"

payload = { "body": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:listing_id/conversations"

payload <- "{\n  \"body\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:listing_id/conversations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"body\": \"\"\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/listings/:listing_id/conversations') do |req|
  req.body = "{\n  \"body\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:listing_id/conversations";

    let payload = json!({"body": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "body": ""
}' |  \
  http POST {{baseUrl}}/listings/:listing_id/conversations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "body": ""\n}' \
  --output-document \
  - {{baseUrl}}/listings/:listing_id/conversations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["body": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:listing_id/conversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:slug");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/listings/:slug" {:content-type :json
                                                          :form-params {:categories [{:uuid ""}]
                                                                        :condition {:uuid ""}
                                                                        :description ""
                                                                        :exclusive_channel ""
                                                                        :finish ""
                                                                        :has_inventory false
                                                                        :inventory 0
                                                                        :location {:country_code ""
                                                                                   :locality ""
                                                                                   :region ""}
                                                                        :make ""
                                                                        :model ""
                                                                        :multi_item false
                                                                        :offers_enabled false
                                                                        :origin_country_code ""
                                                                        :photos []
                                                                        :preorder_info {:lead_time 0
                                                                                        :lead_time_unit ""
                                                                                        :ship_date ""}
                                                                        :price {:amount ""
                                                                                :currency ""}
                                                                        :prop_65_warning ""
                                                                        :publish false
                                                                        :seller {:paypal_email ""}
                                                                        :seller_cost ""
                                                                        :shipping {:local false
                                                                                   :rates [{:rate {:amount ""
                                                                                                   :currency ""}
                                                                                            :region_code ""}]}
                                                                        :shipping_profile_id ""
                                                                        :shipping_profile_name ""
                                                                        :sku ""
                                                                        :sold_as_is false
                                                                        :storage_location ""
                                                                        :tax_exempt false
                                                                        :title ""
                                                                        :upc ""
                                                                        :upc_does_not_apply false
                                                                        :videos [{:link ""}]
                                                                        :year ""}})

require "http/client"

url = "{{baseUrl}}/listings/:slug"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/listings/:slug"),
    Content = new StringContent("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\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}}/listings/:slug");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:slug"

	payload := strings.NewReader("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/listings/:slug HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1108

{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/listings/:slug")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:slug"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\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  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listings/:slug")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/listings/:slug")
  .header("content-type", "application/json")
  .body("{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  categories: [
    {
      uuid: ''
    }
  ],
  condition: {
    uuid: ''
  },
  description: '',
  exclusive_channel: '',
  finish: '',
  has_inventory: false,
  inventory: 0,
  location: {
    country_code: '',
    locality: '',
    region: ''
  },
  make: '',
  model: '',
  multi_item: false,
  offers_enabled: false,
  origin_country_code: '',
  photos: [],
  preorder_info: {
    lead_time: 0,
    lead_time_unit: '',
    ship_date: ''
  },
  price: {
    amount: '',
    currency: ''
  },
  prop_65_warning: '',
  publish: false,
  seller: {
    paypal_email: ''
  },
  seller_cost: '',
  shipping: {
    local: false,
    rates: [
      {
        rate: {
          amount: '',
          currency: ''
        },
        region_code: ''
      }
    ]
  },
  shipping_profile_id: '',
  shipping_profile_name: '',
  sku: '',
  sold_as_is: false,
  storage_location: '',
  tax_exempt: false,
  title: '',
  upc: '',
  upc_does_not_apply: false,
  videos: [
    {
      link: ''
    }
  ],
  year: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/listings/:slug');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/listings/:slug',
  headers: {'content-type': 'application/json'},
  data: {
    categories: [{uuid: ''}],
    condition: {uuid: ''},
    description: '',
    exclusive_channel: '',
    finish: '',
    has_inventory: false,
    inventory: 0,
    location: {country_code: '', locality: '', region: ''},
    make: '',
    model: '',
    multi_item: false,
    offers_enabled: false,
    origin_country_code: '',
    photos: [],
    preorder_info: {lead_time: 0, lead_time_unit: '', ship_date: ''},
    price: {amount: '', currency: ''},
    prop_65_warning: '',
    publish: false,
    seller: {paypal_email: ''},
    seller_cost: '',
    shipping: {local: false, rates: [{rate: {amount: '', currency: ''}, region_code: ''}]},
    shipping_profile_id: '',
    shipping_profile_name: '',
    sku: '',
    sold_as_is: false,
    storage_location: '',
    tax_exempt: false,
    title: '',
    upc: '',
    upc_does_not_apply: false,
    videos: [{link: ''}],
    year: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:slug';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[{"uuid":""}],"condition":{"uuid":""},"description":"","exclusive_channel":"","finish":"","has_inventory":false,"inventory":0,"location":{"country_code":"","locality":"","region":""},"make":"","model":"","multi_item":false,"offers_enabled":false,"origin_country_code":"","photos":[],"preorder_info":{"lead_time":0,"lead_time_unit":"","ship_date":""},"price":{"amount":"","currency":""},"prop_65_warning":"","publish":false,"seller":{"paypal_email":""},"seller_cost":"","shipping":{"local":false,"rates":[{"rate":{"amount":"","currency":""},"region_code":""}]},"shipping_profile_id":"","shipping_profile_name":"","sku":"","sold_as_is":false,"storage_location":"","tax_exempt":false,"title":"","upc":"","upc_does_not_apply":false,"videos":[{"link":""}],"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}}/listings/:slug',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "categories": [\n    {\n      "uuid": ""\n    }\n  ],\n  "condition": {\n    "uuid": ""\n  },\n  "description": "",\n  "exclusive_channel": "",\n  "finish": "",\n  "has_inventory": false,\n  "inventory": 0,\n  "location": {\n    "country_code": "",\n    "locality": "",\n    "region": ""\n  },\n  "make": "",\n  "model": "",\n  "multi_item": false,\n  "offers_enabled": false,\n  "origin_country_code": "",\n  "photos": [],\n  "preorder_info": {\n    "lead_time": 0,\n    "lead_time_unit": "",\n    "ship_date": ""\n  },\n  "price": {\n    "amount": "",\n    "currency": ""\n  },\n  "prop_65_warning": "",\n  "publish": false,\n  "seller": {\n    "paypal_email": ""\n  },\n  "seller_cost": "",\n  "shipping": {\n    "local": false,\n    "rates": [\n      {\n        "rate": {\n          "amount": "",\n          "currency": ""\n        },\n        "region_code": ""\n      }\n    ]\n  },\n  "shipping_profile_id": "",\n  "shipping_profile_name": "",\n  "sku": "",\n  "sold_as_is": false,\n  "storage_location": "",\n  "tax_exempt": false,\n  "title": "",\n  "upc": "",\n  "upc_does_not_apply": false,\n  "videos": [\n    {\n      "link": ""\n    }\n  ],\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  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listings/:slug")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:slug',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  categories: [{uuid: ''}],
  condition: {uuid: ''},
  description: '',
  exclusive_channel: '',
  finish: '',
  has_inventory: false,
  inventory: 0,
  location: {country_code: '', locality: '', region: ''},
  make: '',
  model: '',
  multi_item: false,
  offers_enabled: false,
  origin_country_code: '',
  photos: [],
  preorder_info: {lead_time: 0, lead_time_unit: '', ship_date: ''},
  price: {amount: '', currency: ''},
  prop_65_warning: '',
  publish: false,
  seller: {paypal_email: ''},
  seller_cost: '',
  shipping: {local: false, rates: [{rate: {amount: '', currency: ''}, region_code: ''}]},
  shipping_profile_id: '',
  shipping_profile_name: '',
  sku: '',
  sold_as_is: false,
  storage_location: '',
  tax_exempt: false,
  title: '',
  upc: '',
  upc_does_not_apply: false,
  videos: [{link: ''}],
  year: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/listings/:slug',
  headers: {'content-type': 'application/json'},
  body: {
    categories: [{uuid: ''}],
    condition: {uuid: ''},
    description: '',
    exclusive_channel: '',
    finish: '',
    has_inventory: false,
    inventory: 0,
    location: {country_code: '', locality: '', region: ''},
    make: '',
    model: '',
    multi_item: false,
    offers_enabled: false,
    origin_country_code: '',
    photos: [],
    preorder_info: {lead_time: 0, lead_time_unit: '', ship_date: ''},
    price: {amount: '', currency: ''},
    prop_65_warning: '',
    publish: false,
    seller: {paypal_email: ''},
    seller_cost: '',
    shipping: {local: false, rates: [{rate: {amount: '', currency: ''}, region_code: ''}]},
    shipping_profile_id: '',
    shipping_profile_name: '',
    sku: '',
    sold_as_is: false,
    storage_location: '',
    tax_exempt: false,
    title: '',
    upc: '',
    upc_does_not_apply: false,
    videos: [{link: ''}],
    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('PUT', '{{baseUrl}}/listings/:slug');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  categories: [
    {
      uuid: ''
    }
  ],
  condition: {
    uuid: ''
  },
  description: '',
  exclusive_channel: '',
  finish: '',
  has_inventory: false,
  inventory: 0,
  location: {
    country_code: '',
    locality: '',
    region: ''
  },
  make: '',
  model: '',
  multi_item: false,
  offers_enabled: false,
  origin_country_code: '',
  photos: [],
  preorder_info: {
    lead_time: 0,
    lead_time_unit: '',
    ship_date: ''
  },
  price: {
    amount: '',
    currency: ''
  },
  prop_65_warning: '',
  publish: false,
  seller: {
    paypal_email: ''
  },
  seller_cost: '',
  shipping: {
    local: false,
    rates: [
      {
        rate: {
          amount: '',
          currency: ''
        },
        region_code: ''
      }
    ]
  },
  shipping_profile_id: '',
  shipping_profile_name: '',
  sku: '',
  sold_as_is: false,
  storage_location: '',
  tax_exempt: false,
  title: '',
  upc: '',
  upc_does_not_apply: false,
  videos: [
    {
      link: ''
    }
  ],
  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: 'PUT',
  url: '{{baseUrl}}/listings/:slug',
  headers: {'content-type': 'application/json'},
  data: {
    categories: [{uuid: ''}],
    condition: {uuid: ''},
    description: '',
    exclusive_channel: '',
    finish: '',
    has_inventory: false,
    inventory: 0,
    location: {country_code: '', locality: '', region: ''},
    make: '',
    model: '',
    multi_item: false,
    offers_enabled: false,
    origin_country_code: '',
    photos: [],
    preorder_info: {lead_time: 0, lead_time_unit: '', ship_date: ''},
    price: {amount: '', currency: ''},
    prop_65_warning: '',
    publish: false,
    seller: {paypal_email: ''},
    seller_cost: '',
    shipping: {local: false, rates: [{rate: {amount: '', currency: ''}, region_code: ''}]},
    shipping_profile_id: '',
    shipping_profile_name: '',
    sku: '',
    sold_as_is: false,
    storage_location: '',
    tax_exempt: false,
    title: '',
    upc: '',
    upc_does_not_apply: false,
    videos: [{link: ''}],
    year: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:slug';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[{"uuid":""}],"condition":{"uuid":""},"description":"","exclusive_channel":"","finish":"","has_inventory":false,"inventory":0,"location":{"country_code":"","locality":"","region":""},"make":"","model":"","multi_item":false,"offers_enabled":false,"origin_country_code":"","photos":[],"preorder_info":{"lead_time":0,"lead_time_unit":"","ship_date":""},"price":{"amount":"","currency":""},"prop_65_warning":"","publish":false,"seller":{"paypal_email":""},"seller_cost":"","shipping":{"local":false,"rates":[{"rate":{"amount":"","currency":""},"region_code":""}]},"shipping_profile_id":"","shipping_profile_name":"","sku":"","sold_as_is":false,"storage_location":"","tax_exempt":false,"title":"","upc":"","upc_does_not_apply":false,"videos":[{"link":""}],"year":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"categories": @[ @{ @"uuid": @"" } ],
                              @"condition": @{ @"uuid": @"" },
                              @"description": @"",
                              @"exclusive_channel": @"",
                              @"finish": @"",
                              @"has_inventory": @NO,
                              @"inventory": @0,
                              @"location": @{ @"country_code": @"", @"locality": @"", @"region": @"" },
                              @"make": @"",
                              @"model": @"",
                              @"multi_item": @NO,
                              @"offers_enabled": @NO,
                              @"origin_country_code": @"",
                              @"photos": @[  ],
                              @"preorder_info": @{ @"lead_time": @0, @"lead_time_unit": @"", @"ship_date": @"" },
                              @"price": @{ @"amount": @"", @"currency": @"" },
                              @"prop_65_warning": @"",
                              @"publish": @NO,
                              @"seller": @{ @"paypal_email": @"" },
                              @"seller_cost": @"",
                              @"shipping": @{ @"local": @NO, @"rates": @[ @{ @"rate": @{ @"amount": @"", @"currency": @"" }, @"region_code": @"" } ] },
                              @"shipping_profile_id": @"",
                              @"shipping_profile_name": @"",
                              @"sku": @"",
                              @"sold_as_is": @NO,
                              @"storage_location": @"",
                              @"tax_exempt": @NO,
                              @"title": @"",
                              @"upc": @"",
                              @"upc_does_not_apply": @NO,
                              @"videos": @[ @{ @"link": @"" } ],
                              @"year": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings/:slug"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/listings/:slug" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:slug",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'categories' => [
        [
                'uuid' => ''
        ]
    ],
    'condition' => [
        'uuid' => ''
    ],
    'description' => '',
    'exclusive_channel' => '',
    'finish' => '',
    'has_inventory' => null,
    'inventory' => 0,
    'location' => [
        'country_code' => '',
        'locality' => '',
        'region' => ''
    ],
    'make' => '',
    'model' => '',
    'multi_item' => null,
    'offers_enabled' => null,
    'origin_country_code' => '',
    'photos' => [
        
    ],
    'preorder_info' => [
        'lead_time' => 0,
        'lead_time_unit' => '',
        'ship_date' => ''
    ],
    'price' => [
        'amount' => '',
        'currency' => ''
    ],
    'prop_65_warning' => '',
    'publish' => null,
    'seller' => [
        'paypal_email' => ''
    ],
    'seller_cost' => '',
    'shipping' => [
        'local' => null,
        'rates' => [
                [
                                'rate' => [
                                                                'amount' => '',
                                                                'currency' => ''
                                ],
                                'region_code' => ''
                ]
        ]
    ],
    'shipping_profile_id' => '',
    'shipping_profile_name' => '',
    'sku' => '',
    'sold_as_is' => null,
    'storage_location' => '',
    'tax_exempt' => null,
    'title' => '',
    'upc' => '',
    'upc_does_not_apply' => null,
    'videos' => [
        [
                'link' => ''
        ]
    ],
    'year' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/listings/:slug', [
  'body' => '{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:slug');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'categories' => [
    [
        'uuid' => ''
    ]
  ],
  'condition' => [
    'uuid' => ''
  ],
  'description' => '',
  'exclusive_channel' => '',
  'finish' => '',
  'has_inventory' => null,
  'inventory' => 0,
  'location' => [
    'country_code' => '',
    'locality' => '',
    'region' => ''
  ],
  'make' => '',
  'model' => '',
  'multi_item' => null,
  'offers_enabled' => null,
  'origin_country_code' => '',
  'photos' => [
    
  ],
  'preorder_info' => [
    'lead_time' => 0,
    'lead_time_unit' => '',
    'ship_date' => ''
  ],
  'price' => [
    'amount' => '',
    'currency' => ''
  ],
  'prop_65_warning' => '',
  'publish' => null,
  'seller' => [
    'paypal_email' => ''
  ],
  'seller_cost' => '',
  'shipping' => [
    'local' => null,
    'rates' => [
        [
                'rate' => [
                                'amount' => '',
                                'currency' => ''
                ],
                'region_code' => ''
        ]
    ]
  ],
  'shipping_profile_id' => '',
  'shipping_profile_name' => '',
  'sku' => '',
  'sold_as_is' => null,
  'storage_location' => '',
  'tax_exempt' => null,
  'title' => '',
  'upc' => '',
  'upc_does_not_apply' => null,
  'videos' => [
    [
        'link' => ''
    ]
  ],
  'year' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'categories' => [
    [
        'uuid' => ''
    ]
  ],
  'condition' => [
    'uuid' => ''
  ],
  'description' => '',
  'exclusive_channel' => '',
  'finish' => '',
  'has_inventory' => null,
  'inventory' => 0,
  'location' => [
    'country_code' => '',
    'locality' => '',
    'region' => ''
  ],
  'make' => '',
  'model' => '',
  'multi_item' => null,
  'offers_enabled' => null,
  'origin_country_code' => '',
  'photos' => [
    
  ],
  'preorder_info' => [
    'lead_time' => 0,
    'lead_time_unit' => '',
    'ship_date' => ''
  ],
  'price' => [
    'amount' => '',
    'currency' => ''
  ],
  'prop_65_warning' => '',
  'publish' => null,
  'seller' => [
    'paypal_email' => ''
  ],
  'seller_cost' => '',
  'shipping' => [
    'local' => null,
    'rates' => [
        [
                'rate' => [
                                'amount' => '',
                                'currency' => ''
                ],
                'region_code' => ''
        ]
    ]
  ],
  'shipping_profile_id' => '',
  'shipping_profile_name' => '',
  'sku' => '',
  'sold_as_is' => null,
  'storage_location' => '',
  'tax_exempt' => null,
  'title' => '',
  'upc' => '',
  'upc_does_not_apply' => null,
  'videos' => [
    [
        'link' => ''
    ]
  ],
  'year' => ''
]));
$request->setRequestUrl('{{baseUrl}}/listings/:slug');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:slug' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:slug' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/listings/:slug", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:slug"

payload = {
    "categories": [{ "uuid": "" }],
    "condition": { "uuid": "" },
    "description": "",
    "exclusive_channel": "",
    "finish": "",
    "has_inventory": False,
    "inventory": 0,
    "location": {
        "country_code": "",
        "locality": "",
        "region": ""
    },
    "make": "",
    "model": "",
    "multi_item": False,
    "offers_enabled": False,
    "origin_country_code": "",
    "photos": [],
    "preorder_info": {
        "lead_time": 0,
        "lead_time_unit": "",
        "ship_date": ""
    },
    "price": {
        "amount": "",
        "currency": ""
    },
    "prop_65_warning": "",
    "publish": False,
    "seller": { "paypal_email": "" },
    "seller_cost": "",
    "shipping": {
        "local": False,
        "rates": [
            {
                "rate": {
                    "amount": "",
                    "currency": ""
                },
                "region_code": ""
            }
        ]
    },
    "shipping_profile_id": "",
    "shipping_profile_name": "",
    "sku": "",
    "sold_as_is": False,
    "storage_location": "",
    "tax_exempt": False,
    "title": "",
    "upc": "",
    "upc_does_not_apply": False,
    "videos": [{ "link": "" }],
    "year": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:slug"

payload <- "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:slug")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\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.put('/baseUrl/listings/:slug') do |req|
  req.body = "{\n  \"categories\": [\n    {\n      \"uuid\": \"\"\n    }\n  ],\n  \"condition\": {\n    \"uuid\": \"\"\n  },\n  \"description\": \"\",\n  \"exclusive_channel\": \"\",\n  \"finish\": \"\",\n  \"has_inventory\": false,\n  \"inventory\": 0,\n  \"location\": {\n    \"country_code\": \"\",\n    \"locality\": \"\",\n    \"region\": \"\"\n  },\n  \"make\": \"\",\n  \"model\": \"\",\n  \"multi_item\": false,\n  \"offers_enabled\": false,\n  \"origin_country_code\": \"\",\n  \"photos\": [],\n  \"preorder_info\": {\n    \"lead_time\": 0,\n    \"lead_time_unit\": \"\",\n    \"ship_date\": \"\"\n  },\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"prop_65_warning\": \"\",\n  \"publish\": false,\n  \"seller\": {\n    \"paypal_email\": \"\"\n  },\n  \"seller_cost\": \"\",\n  \"shipping\": {\n    \"local\": false,\n    \"rates\": [\n      {\n        \"rate\": {\n          \"amount\": \"\",\n          \"currency\": \"\"\n        },\n        \"region_code\": \"\"\n      }\n    ]\n  },\n  \"shipping_profile_id\": \"\",\n  \"shipping_profile_name\": \"\",\n  \"sku\": \"\",\n  \"sold_as_is\": false,\n  \"storage_location\": \"\",\n  \"tax_exempt\": false,\n  \"title\": \"\",\n  \"upc\": \"\",\n  \"upc_does_not_apply\": false,\n  \"videos\": [\n    {\n      \"link\": \"\"\n    }\n  ],\n  \"year\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:slug";

    let payload = json!({
        "categories": (json!({"uuid": ""})),
        "condition": json!({"uuid": ""}),
        "description": "",
        "exclusive_channel": "",
        "finish": "",
        "has_inventory": false,
        "inventory": 0,
        "location": json!({
            "country_code": "",
            "locality": "",
            "region": ""
        }),
        "make": "",
        "model": "",
        "multi_item": false,
        "offers_enabled": false,
        "origin_country_code": "",
        "photos": (),
        "preorder_info": json!({
            "lead_time": 0,
            "lead_time_unit": "",
            "ship_date": ""
        }),
        "price": json!({
            "amount": "",
            "currency": ""
        }),
        "prop_65_warning": "",
        "publish": false,
        "seller": json!({"paypal_email": ""}),
        "seller_cost": "",
        "shipping": json!({
            "local": false,
            "rates": (
                json!({
                    "rate": json!({
                        "amount": "",
                        "currency": ""
                    }),
                    "region_code": ""
                })
            )
        }),
        "shipping_profile_id": "",
        "shipping_profile_name": "",
        "sku": "",
        "sold_as_is": false,
        "storage_location": "",
        "tax_exempt": false,
        "title": "",
        "upc": "",
        "upc_does_not_apply": false,
        "videos": (json!({"link": ""})),
        "year": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "categories": [
    {
      "uuid": ""
    }
  ],
  "condition": {
    "uuid": ""
  },
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": {
    "country_code": "",
    "locality": "",
    "region": ""
  },
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": {
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  },
  "price": {
    "amount": "",
    "currency": ""
  },
  "prop_65_warning": "",
  "publish": false,
  "seller": {
    "paypal_email": ""
  },
  "seller_cost": "",
  "shipping": {
    "local": false,
    "rates": [
      {
        "rate": {
          "amount": "",
          "currency": ""
        },
        "region_code": ""
      }
    ]
  },
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [
    {
      "link": ""
    }
  ],
  "year": ""
}' |  \
  http PUT {{baseUrl}}/listings/:slug \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "categories": [\n    {\n      "uuid": ""\n    }\n  ],\n  "condition": {\n    "uuid": ""\n  },\n  "description": "",\n  "exclusive_channel": "",\n  "finish": "",\n  "has_inventory": false,\n  "inventory": 0,\n  "location": {\n    "country_code": "",\n    "locality": "",\n    "region": ""\n  },\n  "make": "",\n  "model": "",\n  "multi_item": false,\n  "offers_enabled": false,\n  "origin_country_code": "",\n  "photos": [],\n  "preorder_info": {\n    "lead_time": 0,\n    "lead_time_unit": "",\n    "ship_date": ""\n  },\n  "price": {\n    "amount": "",\n    "currency": ""\n  },\n  "prop_65_warning": "",\n  "publish": false,\n  "seller": {\n    "paypal_email": ""\n  },\n  "seller_cost": "",\n  "shipping": {\n    "local": false,\n    "rates": [\n      {\n        "rate": {\n          "amount": "",\n          "currency": ""\n        },\n        "region_code": ""\n      }\n    ]\n  },\n  "shipping_profile_id": "",\n  "shipping_profile_name": "",\n  "sku": "",\n  "sold_as_is": false,\n  "storage_location": "",\n  "tax_exempt": false,\n  "title": "",\n  "upc": "",\n  "upc_does_not_apply": false,\n  "videos": [\n    {\n      "link": ""\n    }\n  ],\n  "year": ""\n}' \
  --output-document \
  - {{baseUrl}}/listings/:slug

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "categories": [["uuid": ""]],
  "condition": ["uuid": ""],
  "description": "",
  "exclusive_channel": "",
  "finish": "",
  "has_inventory": false,
  "inventory": 0,
  "location": [
    "country_code": "",
    "locality": "",
    "region": ""
  ],
  "make": "",
  "model": "",
  "multi_item": false,
  "offers_enabled": false,
  "origin_country_code": "",
  "photos": [],
  "preorder_info": [
    "lead_time": 0,
    "lead_time_unit": "",
    "ship_date": ""
  ],
  "price": [
    "amount": "",
    "currency": ""
  ],
  "prop_65_warning": "",
  "publish": false,
  "seller": ["paypal_email": ""],
  "seller_cost": "",
  "shipping": [
    "local": false,
    "rates": [
      [
        "rate": [
          "amount": "",
          "currency": ""
        ],
        "region_code": ""
      ]
    ]
  ],
  "shipping_profile_id": "",
  "shipping_profile_name": "",
  "sku": "",
  "sold_as_is": false,
  "storage_location": "",
  "tax_exempt": false,
  "title": "",
  "upc": "",
  "upc_does_not_apply": false,
  "videos": [["link": ""]],
  "year": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:slug")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:listing_id/bump");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/:listing_id/bump")

require "http/client"

url = "{{baseUrl}}/listings/:listing_id/bump"

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}}/listings/:listing_id/bump"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:listing_id/bump");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:listing_id/bump"

	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/listings/:listing_id/bump HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/:listing_id/bump")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:listing_id/bump"))
    .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}}/listings/:listing_id/bump")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/:listing_id/bump")
  .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}}/listings/:listing_id/bump');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listings/:listing_id/bump'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:listing_id/bump';
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}}/listings/:listing_id/bump',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:listing_id/bump")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:listing_id/bump',
  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}}/listings/:listing_id/bump'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/:listing_id/bump');

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}}/listings/:listing_id/bump'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:listing_id/bump';
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}}/listings/:listing_id/bump"]
                                                       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}}/listings/:listing_id/bump" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:listing_id/bump",
  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}}/listings/:listing_id/bump');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:listing_id/bump');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:listing_id/bump');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:listing_id/bump' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:listing_id/bump' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/:listing_id/bump")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:listing_id/bump"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:listing_id/bump"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:listing_id/bump")

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/listings/:listing_id/bump') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:listing_id/bump";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/:listing_id/bump

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/:listing_id/bump

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:listing_id/bump")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:slug/reviews");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/:slug/reviews")

require "http/client"

url = "{{baseUrl}}/listings/:slug/reviews"

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}}/listings/:slug/reviews"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:slug/reviews");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:slug/reviews"

	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/listings/:slug/reviews HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/:slug/reviews")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:slug/reviews"))
    .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}}/listings/:slug/reviews")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/:slug/reviews")
  .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}}/listings/:slug/reviews');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listings/:slug/reviews'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:slug/reviews';
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}}/listings/:slug/reviews',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:slug/reviews")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:slug/reviews',
  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}}/listings/:slug/reviews'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/:slug/reviews');

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}}/listings/:slug/reviews'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:slug/reviews';
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}}/listings/:slug/reviews"]
                                                       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}}/listings/:slug/reviews" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:slug/reviews",
  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}}/listings/:slug/reviews');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:slug/reviews');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:slug/reviews');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:slug/reviews' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:slug/reviews' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/:slug/reviews")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:slug/reviews"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:slug/reviews"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:slug/reviews")

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/listings/:slug/reviews') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:slug/reviews";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/:slug/reviews

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/:slug/reviews

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:slug/reviews")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings/:listing_id/images");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/listings/:listing_id/images")

require "http/client"

url = "{{baseUrl}}/listings/:listing_id/images"

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}}/listings/:listing_id/images"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/listings/:listing_id/images");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/listings/:listing_id/images"

	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/listings/:listing_id/images HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings/:listing_id/images")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listings/:listing_id/images"))
    .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}}/listings/:listing_id/images")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/listings/:listing_id/images")
  .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}}/listings/:listing_id/images');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/listings/:listing_id/images'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/listings/:listing_id/images';
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}}/listings/:listing_id/images',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/listings/:listing_id/images")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/listings/:listing_id/images',
  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}}/listings/:listing_id/images'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/listings/:listing_id/images');

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}}/listings/:listing_id/images'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/listings/:listing_id/images';
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}}/listings/:listing_id/images"]
                                                       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}}/listings/:listing_id/images" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/listings/:listing_id/images",
  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}}/listings/:listing_id/images');

echo $response->getBody();

setUrl('{{baseUrl}}/listings/:listing_id/images');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/listings/:listing_id/images');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings/:listing_id/images' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/listings/:listing_id/images' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/listings/:listing_id/images")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/listings/:listing_id/images"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/listings/:listing_id/images"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/listings/:listing_id/images")

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/listings/:listing_id/images') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/listings/:listing_id/images";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/listings/:listing_id/images

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/listings/:listing_id/images

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings/:listing_id/images")! 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}}/my/negotiations/:id/accept");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"message\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/my/negotiations/:id/accept" {:content-type :json
                                                                       :form-params {:message ""}})

require "http/client"

url = "{{baseUrl}}/my/negotiations/:id/accept"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"message\": \"\"\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}}/my/negotiations/:id/accept"),
    Content = new StringContent("{\n  \"message\": \"\"\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}}/my/negotiations/:id/accept");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"message\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/negotiations/:id/accept"

	payload := strings.NewReader("{\n  \"message\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/my/negotiations/:id/accept HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "message": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/negotiations/:id/accept")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"message\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/negotiations/:id/accept"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"message\": \"\"\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  \"message\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/my/negotiations/:id/accept")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/my/negotiations/:id/accept")
  .header("content-type", "application/json")
  .body("{\n  \"message\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  message: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/my/negotiations/:id/accept');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/my/negotiations/:id/accept',
  headers: {'content-type': 'application/json'},
  data: {message: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/negotiations/:id/accept';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"message":""}'
};

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}}/my/negotiations/:id/accept',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "message": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"message\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/my/negotiations/:id/accept")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/negotiations/:id/accept',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({message: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/my/negotiations/:id/accept',
  headers: {'content-type': 'application/json'},
  body: {message: ''},
  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}}/my/negotiations/:id/accept');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  message: ''
});

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}}/my/negotiations/:id/accept',
  headers: {'content-type': 'application/json'},
  data: {message: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/negotiations/:id/accept';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"message":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"message": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/negotiations/:id/accept"]
                                                       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}}/my/negotiations/:id/accept" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"message\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/negotiations/:id/accept",
  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([
    'message' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/my/negotiations/:id/accept', [
  'body' => '{
  "message": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/my/negotiations/:id/accept');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'message' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'message' => ''
]));
$request->setRequestUrl('{{baseUrl}}/my/negotiations/:id/accept');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/negotiations/:id/accept' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/negotiations/:id/accept' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"message\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/my/negotiations/:id/accept", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/negotiations/:id/accept"

payload = { "message": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/negotiations/:id/accept"

payload <- "{\n  \"message\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/negotiations/:id/accept")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"message\": \"\"\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/my/negotiations/:id/accept') do |req|
  req.body = "{\n  \"message\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/negotiations/:id/accept";

    let payload = json!({"message": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "message": ""
}' |  \
  http POST {{baseUrl}}/my/negotiations/:id/accept \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "message": ""\n}' \
  --output-document \
  - {{baseUrl}}/my/negotiations/:id/accept

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["message": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/negotiations/:id/accept")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/wishlist/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/my/wishlist/:id")

require "http/client"

url = "{{baseUrl}}/my/wishlist/:id"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/my/wishlist/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/my/wishlist/:id");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/wishlist/:id"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/my/wishlist/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/wishlist/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/wishlist/:id"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/my/wishlist/:id")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/my/wishlist/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/my/wishlist/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/my/wishlist/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/wishlist/:id';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/my/wishlist/:id',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/my/wishlist/:id")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/wishlist/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/my/wishlist/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/my/wishlist/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'PUT', url: '{{baseUrl}}/my/wishlist/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/wishlist/:id';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/wishlist/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/my/wishlist/:id" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/wishlist/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/my/wishlist/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/my/wishlist/:id');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/my/wishlist/:id');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/wishlist/:id' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/wishlist/:id' -Method PUT 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/my/wishlist/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/wishlist/:id"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/wishlist/:id"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/wishlist/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/my/wishlist/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/wishlist/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT {{baseUrl}}/my/wishlist/:id

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/my/wishlist/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/wishlist/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/negotiations/:id/counter");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/my/negotiations/:id/counter" {:content-type :json
                                                                        :form-params {:country_code ""
                                                                                      :layaway_terms_slug ""
                                                                                      :message ""
                                                                                      :offer_items [{:listing_id ""
                                                                                                     :price ""
                                                                                                     :shipping_price ""}]
                                                                                      :price {:amount ""
                                                                                              :currency ""}
                                                                                      :quantity ""
                                                                                      :recipient_id ""
                                                                                      :region_code ""
                                                                                      :shipping_price {:amount ""
                                                                                                       :currency ""}}})

require "http/client"

url = "{{baseUrl}}/my/negotiations/:id/counter"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\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}}/my/negotiations/:id/counter"),
    Content = new StringContent("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\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}}/my/negotiations/:id/counter");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/negotiations/:id/counter"

	payload := strings.NewReader("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/my/negotiations/:id/counter HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 355

{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/negotiations/:id/counter")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/negotiations/:id/counter"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\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  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/my/negotiations/:id/counter")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/my/negotiations/:id/counter")
  .header("content-type", "application/json")
  .body("{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  country_code: '',
  layaway_terms_slug: '',
  message: '',
  offer_items: [
    {
      listing_id: '',
      price: '',
      shipping_price: ''
    }
  ],
  price: {
    amount: '',
    currency: ''
  },
  quantity: '',
  recipient_id: '',
  region_code: '',
  shipping_price: {
    amount: '',
    currency: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/my/negotiations/:id/counter');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/my/negotiations/:id/counter',
  headers: {'content-type': 'application/json'},
  data: {
    country_code: '',
    layaway_terms_slug: '',
    message: '',
    offer_items: [{listing_id: '', price: '', shipping_price: ''}],
    price: {amount: '', currency: ''},
    quantity: '',
    recipient_id: '',
    region_code: '',
    shipping_price: {amount: '', currency: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/negotiations/:id/counter';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"country_code":"","layaway_terms_slug":"","message":"","offer_items":[{"listing_id":"","price":"","shipping_price":""}],"price":{"amount":"","currency":""},"quantity":"","recipient_id":"","region_code":"","shipping_price":{"amount":"","currency":""}}'
};

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}}/my/negotiations/:id/counter',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "country_code": "",\n  "layaway_terms_slug": "",\n  "message": "",\n  "offer_items": [\n    {\n      "listing_id": "",\n      "price": "",\n      "shipping_price": ""\n    }\n  ],\n  "price": {\n    "amount": "",\n    "currency": ""\n  },\n  "quantity": "",\n  "recipient_id": "",\n  "region_code": "",\n  "shipping_price": {\n    "amount": "",\n    "currency": ""\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  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/my/negotiations/:id/counter")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/negotiations/:id/counter',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  country_code: '',
  layaway_terms_slug: '',
  message: '',
  offer_items: [{listing_id: '', price: '', shipping_price: ''}],
  price: {amount: '', currency: ''},
  quantity: '',
  recipient_id: '',
  region_code: '',
  shipping_price: {amount: '', currency: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/my/negotiations/:id/counter',
  headers: {'content-type': 'application/json'},
  body: {
    country_code: '',
    layaway_terms_slug: '',
    message: '',
    offer_items: [{listing_id: '', price: '', shipping_price: ''}],
    price: {amount: '', currency: ''},
    quantity: '',
    recipient_id: '',
    region_code: '',
    shipping_price: {amount: '', currency: ''}
  },
  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}}/my/negotiations/:id/counter');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  country_code: '',
  layaway_terms_slug: '',
  message: '',
  offer_items: [
    {
      listing_id: '',
      price: '',
      shipping_price: ''
    }
  ],
  price: {
    amount: '',
    currency: ''
  },
  quantity: '',
  recipient_id: '',
  region_code: '',
  shipping_price: {
    amount: '',
    currency: ''
  }
});

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}}/my/negotiations/:id/counter',
  headers: {'content-type': 'application/json'},
  data: {
    country_code: '',
    layaway_terms_slug: '',
    message: '',
    offer_items: [{listing_id: '', price: '', shipping_price: ''}],
    price: {amount: '', currency: ''},
    quantity: '',
    recipient_id: '',
    region_code: '',
    shipping_price: {amount: '', currency: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/negotiations/:id/counter';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"country_code":"","layaway_terms_slug":"","message":"","offer_items":[{"listing_id":"","price":"","shipping_price":""}],"price":{"amount":"","currency":""},"quantity":"","recipient_id":"","region_code":"","shipping_price":{"amount":"","currency":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"country_code": @"",
                              @"layaway_terms_slug": @"",
                              @"message": @"",
                              @"offer_items": @[ @{ @"listing_id": @"", @"price": @"", @"shipping_price": @"" } ],
                              @"price": @{ @"amount": @"", @"currency": @"" },
                              @"quantity": @"",
                              @"recipient_id": @"",
                              @"region_code": @"",
                              @"shipping_price": @{ @"amount": @"", @"currency": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/negotiations/:id/counter"]
                                                       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}}/my/negotiations/:id/counter" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/negotiations/:id/counter",
  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([
    'country_code' => '',
    'layaway_terms_slug' => '',
    'message' => '',
    'offer_items' => [
        [
                'listing_id' => '',
                'price' => '',
                'shipping_price' => ''
        ]
    ],
    'price' => [
        'amount' => '',
        'currency' => ''
    ],
    'quantity' => '',
    'recipient_id' => '',
    'region_code' => '',
    'shipping_price' => [
        'amount' => '',
        'currency' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/my/negotiations/:id/counter', [
  'body' => '{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/my/negotiations/:id/counter');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'country_code' => '',
  'layaway_terms_slug' => '',
  'message' => '',
  'offer_items' => [
    [
        'listing_id' => '',
        'price' => '',
        'shipping_price' => ''
    ]
  ],
  'price' => [
    'amount' => '',
    'currency' => ''
  ],
  'quantity' => '',
  'recipient_id' => '',
  'region_code' => '',
  'shipping_price' => [
    'amount' => '',
    'currency' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'country_code' => '',
  'layaway_terms_slug' => '',
  'message' => '',
  'offer_items' => [
    [
        'listing_id' => '',
        'price' => '',
        'shipping_price' => ''
    ]
  ],
  'price' => [
    'amount' => '',
    'currency' => ''
  ],
  'quantity' => '',
  'recipient_id' => '',
  'region_code' => '',
  'shipping_price' => [
    'amount' => '',
    'currency' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/my/negotiations/:id/counter');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/negotiations/:id/counter' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/negotiations/:id/counter' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/my/negotiations/:id/counter", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/negotiations/:id/counter"

payload = {
    "country_code": "",
    "layaway_terms_slug": "",
    "message": "",
    "offer_items": [
        {
            "listing_id": "",
            "price": "",
            "shipping_price": ""
        }
    ],
    "price": {
        "amount": "",
        "currency": ""
    },
    "quantity": "",
    "recipient_id": "",
    "region_code": "",
    "shipping_price": {
        "amount": "",
        "currency": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/negotiations/:id/counter"

payload <- "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/negotiations/:id/counter")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\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/my/negotiations/:id/counter') do |req|
  req.body = "{\n  \"country_code\": \"\",\n  \"layaway_terms_slug\": \"\",\n  \"message\": \"\",\n  \"offer_items\": [\n    {\n      \"listing_id\": \"\",\n      \"price\": \"\",\n      \"shipping_price\": \"\"\n    }\n  ],\n  \"price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  },\n  \"quantity\": \"\",\n  \"recipient_id\": \"\",\n  \"region_code\": \"\",\n  \"shipping_price\": {\n    \"amount\": \"\",\n    \"currency\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/negotiations/:id/counter";

    let payload = json!({
        "country_code": "",
        "layaway_terms_slug": "",
        "message": "",
        "offer_items": (
            json!({
                "listing_id": "",
                "price": "",
                "shipping_price": ""
            })
        ),
        "price": json!({
            "amount": "",
            "currency": ""
        }),
        "quantity": "",
        "recipient_id": "",
        "region_code": "",
        "shipping_price": json!({
            "amount": "",
            "currency": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    {
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    }
  ],
  "price": {
    "amount": "",
    "currency": ""
  },
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": {
    "amount": "",
    "currency": ""
  }
}' |  \
  http POST {{baseUrl}}/my/negotiations/:id/counter \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "country_code": "",\n  "layaway_terms_slug": "",\n  "message": "",\n  "offer_items": [\n    {\n      "listing_id": "",\n      "price": "",\n      "shipping_price": ""\n    }\n  ],\n  "price": {\n    "amount": "",\n    "currency": ""\n  },\n  "quantity": "",\n  "recipient_id": "",\n  "region_code": "",\n  "shipping_price": {\n    "amount": "",\n    "currency": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/my/negotiations/:id/counter

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "country_code": "",
  "layaway_terms_slug": "",
  "message": "",
  "offer_items": [
    [
      "listing_id": "",
      "price": "",
      "shipping_price": ""
    ]
  ],
  "price": [
    "amount": "",
    "currency": ""
  ],
  "quantity": "",
  "recipient_id": "",
  "region_code": "",
  "shipping_price": [
    "amount": "",
    "currency": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/negotiations/:id/counter")! 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}}/my/addresses");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/my/addresses")

require "http/client"

url = "{{baseUrl}}/my/addresses"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/my/addresses"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/my/addresses");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/addresses"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/my/addresses HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/addresses")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/addresses"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/my/addresses")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/my/addresses")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/my/addresses');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/my/addresses'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/addresses';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/my/addresses',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/my/addresses")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/addresses',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/my/addresses'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/my/addresses');

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}}/my/addresses'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/addresses';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/addresses"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/my/addresses" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/addresses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/my/addresses');

echo $response->getBody();

setUrl('{{baseUrl}}/my/addresses');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/my/addresses');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/addresses' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/addresses' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/my/addresses")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/addresses"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/addresses"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/addresses")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/my/addresses') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/addresses";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/my/addresses

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/my/addresses

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/addresses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/negotiations/:id/decline");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/my/negotiations/:id/decline")

require "http/client"

url = "{{baseUrl}}/my/negotiations/:id/decline"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/my/negotiations/:id/decline"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/my/negotiations/:id/decline");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/negotiations/:id/decline"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/my/negotiations/:id/decline HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/negotiations/:id/decline")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/negotiations/:id/decline"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/my/negotiations/:id/decline")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/my/negotiations/:id/decline")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/my/negotiations/:id/decline');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/my/negotiations/:id/decline'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/negotiations/:id/decline';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/my/negotiations/:id/decline',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/my/negotiations/:id/decline")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/negotiations/:id/decline',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/my/negotiations/:id/decline'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/my/negotiations/:id/decline');

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}}/my/negotiations/:id/decline'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/negotiations/:id/decline';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/negotiations/:id/decline"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/my/negotiations/:id/decline" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/negotiations/:id/decline",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/my/negotiations/:id/decline');

echo $response->getBody();

setUrl('{{baseUrl}}/my/negotiations/:id/decline');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/my/negotiations/:id/decline');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/negotiations/:id/decline' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/negotiations/:id/decline' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/my/negotiations/:id/decline")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/negotiations/:id/decline"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/negotiations/:id/decline"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/negotiations/:id/decline")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/my/negotiations/:id/decline') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/negotiations/:id/decline";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/my/negotiations/:id/decline

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/my/negotiations/:id/decline

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/negotiations/:id/decline")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/follows/:follow_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/my/follows/:follow_id")

require "http/client"

url = "{{baseUrl}}/my/follows/:follow_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/my/follows/:follow_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/my/follows/:follow_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/follows/:follow_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/my/follows/:follow_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/follows/:follow_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/follows/:follow_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/my/follows/:follow_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/my/follows/:follow_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/my/follows/:follow_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/my/follows/:follow_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/follows/:follow_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/my/follows/:follow_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/my/follows/:follow_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/follows/:follow_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/my/follows/:follow_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/my/follows/:follow_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/my/follows/:follow_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/follows/:follow_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/follows/:follow_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/my/follows/:follow_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/follows/:follow_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/my/follows/:follow_id');

echo $response->getBody();

setUrl('{{baseUrl}}/my/follows/:follow_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/my/follows/:follow_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/follows/:follow_id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/follows/:follow_id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/my/follows/:follow_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/follows/:follow_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/follows/:follow_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/follows/:follow_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/my/follows/:follow_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/follows/:follow_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/my/follows/:follow_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/my/follows/:follow_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/follows/:follow_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/addresses/:address_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/my/addresses/:address_id")

require "http/client"

url = "{{baseUrl}}/my/addresses/:address_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/my/addresses/:address_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/my/addresses/:address_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/addresses/:address_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/my/addresses/:address_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/addresses/:address_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/addresses/:address_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/my/addresses/:address_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/my/addresses/:address_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/my/addresses/:address_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/my/addresses/:address_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/addresses/:address_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/my/addresses/:address_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/my/addresses/:address_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/addresses/:address_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/my/addresses/:address_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/my/addresses/:address_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/my/addresses/:address_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/addresses/:address_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/addresses/:address_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/my/addresses/:address_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/addresses/:address_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/my/addresses/:address_id');

echo $response->getBody();

setUrl('{{baseUrl}}/my/addresses/:address_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/my/addresses/:address_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/addresses/:address_id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/addresses/:address_id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/my/addresses/:address_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/addresses/:address_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/addresses/:address_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/addresses/:address_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/my/addresses/:address_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/addresses/:address_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/my/addresses/:address_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/my/addresses/:address_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/addresses/:address_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/conversations/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/my/conversations/:id")

require "http/client"

url = "{{baseUrl}}/my/conversations/:id"

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}}/my/conversations/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/my/conversations/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/conversations/:id"

	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/my/conversations/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/conversations/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/conversations/:id"))
    .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}}/my/conversations/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/my/conversations/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/my/conversations/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/my/conversations/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/conversations/:id';
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}}/my/conversations/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/my/conversations/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/conversations/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/my/conversations/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/my/conversations/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/my/conversations/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/conversations/:id';
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}}/my/conversations/:id"]
                                                       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}}/my/conversations/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/conversations/:id",
  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}}/my/conversations/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/my/conversations/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/my/conversations/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/conversations/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/conversations/:id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/my/conversations/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/conversations/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/conversations/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/conversations/:id")

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/my/conversations/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/conversations/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/my/conversations/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/my/conversations/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/conversations/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/listings/:slug/state/end");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"reason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/my/listings/:slug/state/end" {:content-type :json
                                                                       :form-params {:reason ""}})

require "http/client"

url = "{{baseUrl}}/my/listings/:slug/state/end"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"reason\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/my/listings/:slug/state/end"),
    Content = new StringContent("{\n  \"reason\": \"\"\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}}/my/listings/:slug/state/end");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/listings/:slug/state/end"

	payload := strings.NewReader("{\n  \"reason\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/my/listings/:slug/state/end HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/listings/:slug/state/end")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/listings/:slug/state/end"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"reason\": \"\"\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  \"reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/my/listings/:slug/state/end")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/my/listings/:slug/state/end")
  .header("content-type", "application/json")
  .body("{\n  \"reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  reason: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/my/listings/:slug/state/end');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/my/listings/:slug/state/end',
  headers: {'content-type': 'application/json'},
  data: {reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/listings/:slug/state/end';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"reason":""}'
};

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}}/my/listings/:slug/state/end',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "reason": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/my/listings/:slug/state/end")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/listings/:slug/state/end',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/my/listings/:slug/state/end',
  headers: {'content-type': 'application/json'},
  body: {reason: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/my/listings/:slug/state/end');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  reason: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/my/listings/:slug/state/end',
  headers: {'content-type': 'application/json'},
  data: {reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/listings/:slug/state/end';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"reason": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/listings/:slug/state/end"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/my/listings/:slug/state/end" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"reason\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/listings/:slug/state/end",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/my/listings/:slug/state/end', [
  'body' => '{
  "reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/my/listings/:slug/state/end');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'reason' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/my/listings/:slug/state/end');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/listings/:slug/state/end' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "reason": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/listings/:slug/state/end' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "reason": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"reason\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/my/listings/:slug/state/end", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/listings/:slug/state/end"

payload = { "reason": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/listings/:slug/state/end"

payload <- "{\n  \"reason\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/listings/:slug/state/end")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"reason\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/my/listings/:slug/state/end') do |req|
  req.body = "{\n  \"reason\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/listings/:slug/state/end";

    let payload = json!({"reason": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "reason": ""
}' |  \
  http PUT {{baseUrl}}/my/listings/:slug/state/end \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "reason": ""\n}' \
  --output-document \
  - {{baseUrl}}/my/listings/:slug/state/end

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["reason": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/listings/:slug/state/end")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/follows/brands/:slug");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/my/follows/brands/:slug")

require "http/client"

url = "{{baseUrl}}/my/follows/brands/:slug"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/my/follows/brands/:slug"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/my/follows/brands/:slug");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/follows/brands/:slug"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/my/follows/brands/:slug HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/follows/brands/:slug")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/follows/brands/:slug"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/my/follows/brands/:slug")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/my/follows/brands/:slug")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/my/follows/brands/:slug');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/my/follows/brands/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/follows/brands/:slug';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/my/follows/brands/:slug',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/my/follows/brands/:slug")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/follows/brands/:slug',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/my/follows/brands/:slug'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/my/follows/brands/:slug');

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}}/my/follows/brands/:slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/follows/brands/:slug';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/follows/brands/:slug"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/my/follows/brands/:slug" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/my/follows/brands/:slug",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/my/follows/brands/:slug');

echo $response->getBody();

setUrl('{{baseUrl}}/my/follows/brands/:slug');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/my/follows/brands/:slug');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/follows/brands/:slug' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/follows/brands/:slug' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/my/follows/brands/:slug")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/my/follows/brands/:slug"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/my/follows/brands/:slug"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/my/follows/brands/:slug")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/my/follows/brands/:slug') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/my/follows/brands/:slug";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/my/follows/brands/:slug

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/my/follows/brands/:slug

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/follows/brands/:slug")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/follows/categories/:uuid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/my/follows/categories/:uuid")

require "http/client"

url = "{{baseUrl}}/my/follows/categories/:uuid"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/my/follows/categories/:uuid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/my/follows/categories/:uuid");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/my/follows/categories/:uuid"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/my/follows/categories/:uuid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/follows/categories/:uuid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/my/follows/categories/:uuid"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/my/follows/categories/:uuid")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/my/follows/categories/:uuid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/my/follows/categories/:uuid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/my/follows/categories/:uuid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/my/follows/categories/:uuid';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/my/follows/categories/:uuid',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/my/follows/categories/:uuid")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/my/follows/categories/:uuid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/my/follows/categories/:uuid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/my/follows/categories/:uuid');

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}}/my/follows/categories/:uuid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/my/follows/categories/:uuid';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/follows/categories/:uuid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];