CURL *hnd = curl_easy_init();

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

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/3dsecure" {:content-type :json
                                                     :form-params {:_links [{:rel ""}]
                                                                   :amount ""
                                                                   :cavv ""
                                                                   :createdTime ""
                                                                   :currency ""
                                                                   :customerId ""
                                                                   :eci 0
                                                                   :enrolled ""
                                                                   :enrollmentEci ""
                                                                   :gatewayAccountId ""
                                                                   :id ""
                                                                   :payerAuthResponseStatus ""
                                                                   :paymentCardId ""
                                                                   :signatureVerification ""
                                                                   :websiteId ""
                                                                   :xid ""}})

require "http/client"

url = "{{baseUrl}}/3dsecure"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\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}}/3dsecure"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\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}}/3dsecure");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/3dsecure"

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\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/3dsecure HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 348

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "amount": "",
  "cavv": "",
  "createdTime": "",
  "currency": "",
  "customerId": "",
  "eci": 0,
  "enrolled": "",
  "enrollmentEci": "",
  "gatewayAccountId": "",
  "id": "",
  "payerAuthResponseStatus": "",
  "paymentCardId": "",
  "signatureVerification": "",
  "websiteId": "",
  "xid": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/3dsecure")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/3dsecure"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/3dsecure")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/3dsecure")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  amount: '',
  cavv: '',
  createdTime: '',
  currency: '',
  customerId: '',
  eci: 0,
  enrolled: '',
  enrollmentEci: '',
  gatewayAccountId: '',
  id: '',
  payerAuthResponseStatus: '',
  paymentCardId: '',
  signatureVerification: '',
  websiteId: '',
  xid: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/3dsecure');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/3dsecure',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    amount: '',
    cavv: '',
    createdTime: '',
    currency: '',
    customerId: '',
    eci: 0,
    enrolled: '',
    enrollmentEci: '',
    gatewayAccountId: '',
    id: '',
    payerAuthResponseStatus: '',
    paymentCardId: '',
    signatureVerification: '',
    websiteId: '',
    xid: ''
  }
};

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

const url = '{{baseUrl}}/3dsecure';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"amount":"","cavv":"","createdTime":"","currency":"","customerId":"","eci":0,"enrolled":"","enrollmentEci":"","gatewayAccountId":"","id":"","payerAuthResponseStatus":"","paymentCardId":"","signatureVerification":"","websiteId":"","xid":""}'
};

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}}/3dsecure',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "amount": "",\n  "cavv": "",\n  "createdTime": "",\n  "currency": "",\n  "customerId": "",\n  "eci": 0,\n  "enrolled": "",\n  "enrollmentEci": "",\n  "gatewayAccountId": "",\n  "id": "",\n  "payerAuthResponseStatus": "",\n  "paymentCardId": "",\n  "signatureVerification": "",\n  "websiteId": "",\n  "xid": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/3dsecure")
  .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/3dsecure',
  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({
  _links: [{rel: ''}],
  amount: '',
  cavv: '',
  createdTime: '',
  currency: '',
  customerId: '',
  eci: 0,
  enrolled: '',
  enrollmentEci: '',
  gatewayAccountId: '',
  id: '',
  payerAuthResponseStatus: '',
  paymentCardId: '',
  signatureVerification: '',
  websiteId: '',
  xid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/3dsecure',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [{rel: ''}],
    amount: '',
    cavv: '',
    createdTime: '',
    currency: '',
    customerId: '',
    eci: 0,
    enrolled: '',
    enrollmentEci: '',
    gatewayAccountId: '',
    id: '',
    payerAuthResponseStatus: '',
    paymentCardId: '',
    signatureVerification: '',
    websiteId: '',
    xid: ''
  },
  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}}/3dsecure');

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

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  amount: '',
  cavv: '',
  createdTime: '',
  currency: '',
  customerId: '',
  eci: 0,
  enrolled: '',
  enrollmentEci: '',
  gatewayAccountId: '',
  id: '',
  payerAuthResponseStatus: '',
  paymentCardId: '',
  signatureVerification: '',
  websiteId: '',
  xid: ''
});

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}}/3dsecure',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    amount: '',
    cavv: '',
    createdTime: '',
    currency: '',
    customerId: '',
    eci: 0,
    enrolled: '',
    enrollmentEci: '',
    gatewayAccountId: '',
    id: '',
    payerAuthResponseStatus: '',
    paymentCardId: '',
    signatureVerification: '',
    websiteId: '',
    xid: ''
  }
};

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

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

const url = '{{baseUrl}}/3dsecure';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"amount":"","cavv":"","createdTime":"","currency":"","customerId":"","eci":0,"enrolled":"","enrollmentEci":"","gatewayAccountId":"","id":"","payerAuthResponseStatus":"","paymentCardId":"","signatureVerification":"","websiteId":"","xid":""}'
};

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 = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"amount": @"",
                              @"cavv": @"",
                              @"createdTime": @"",
                              @"currency": @"",
                              @"customerId": @"",
                              @"eci": @0,
                              @"enrolled": @"",
                              @"enrollmentEci": @"",
                              @"gatewayAccountId": @"",
                              @"id": @"",
                              @"payerAuthResponseStatus": @"",
                              @"paymentCardId": @"",
                              @"signatureVerification": @"",
                              @"websiteId": @"",
                              @"xid": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/3dsecure"]
                                                       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}}/3dsecure" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\n}" in

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

 "{{baseUrl}}/3dsecure",
  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([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'amount' => '',
    'cavv' => '',
    'createdTime' => '',
    'currency' => '',
    'customerId' => '',
    'eci' => 0,
    'enrolled' => '',
    'enrollmentEci' => '',
    'gatewayAccountId' => '',
    'id' => '',
    'payerAuthResponseStatus' => '',
    'paymentCardId' => '',
    'signatureVerification' => '',
    'websiteId' => '',
    'xid' => ''
  ]),
  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}}/3dsecure', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "amount": "",
  "cavv": "",
  "createdTime": "",
  "currency": "",
  "customerId": "",
  "eci": 0,
  "enrolled": "",
  "enrollmentEci": "",
  "gatewayAccountId": "",
  "id": "",
  "payerAuthResponseStatus": "",
  "paymentCardId": "",
  "signatureVerification": "",
  "websiteId": "",
  "xid": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'amount' => '',
  'cavv' => '',
  'createdTime' => '',
  'currency' => '',
  'customerId' => '',
  'eci' => 0,
  'enrolled' => '',
  'enrollmentEci' => '',
  'gatewayAccountId' => '',
  'id' => '',
  'payerAuthResponseStatus' => '',
  'paymentCardId' => '',
  'signatureVerification' => '',
  'websiteId' => '',
  'xid' => ''
]));

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

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

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'amount' => '',
  'cavv' => '',
  'createdTime' => '',
  'currency' => '',
  'customerId' => '',
  'eci' => 0,
  'enrolled' => '',
  'enrollmentEci' => '',
  'gatewayAccountId' => '',
  'id' => '',
  'payerAuthResponseStatus' => '',
  'paymentCardId' => '',
  'signatureVerification' => '',
  'websiteId' => '',
  'xid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/3dsecure');
$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}}/3dsecure' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "amount": "",
  "cavv": "",
  "createdTime": "",
  "currency": "",
  "customerId": "",
  "eci": 0,
  "enrolled": "",
  "enrollmentEci": "",
  "gatewayAccountId": "",
  "id": "",
  "payerAuthResponseStatus": "",
  "paymentCardId": "",
  "signatureVerification": "",
  "websiteId": "",
  "xid": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/3dsecure' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "amount": "",
  "cavv": "",
  "createdTime": "",
  "currency": "",
  "customerId": "",
  "eci": 0,
  "enrolled": "",
  "enrollmentEci": "",
  "gatewayAccountId": "",
  "id": "",
  "payerAuthResponseStatus": "",
  "paymentCardId": "",
  "signatureVerification": "",
  "websiteId": "",
  "xid": ""
}'

import http.client

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

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/3dsecure"

payload = {
    "_links": [{ "rel": "" }],
    "amount": "",
    "cavv": "",
    "createdTime": "",
    "currency": "",
    "customerId": "",
    "eci": 0,
    "enrolled": "",
    "enrollmentEci": "",
    "gatewayAccountId": "",
    "id": "",
    "payerAuthResponseStatus": "",
    "paymentCardId": "",
    "signatureVerification": "",
    "websiteId": "",
    "xid": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/3dsecure"

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\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}}/3dsecure")

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\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/3dsecure') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"amount\": \"\",\n  \"cavv\": \"\",\n  \"createdTime\": \"\",\n  \"currency\": \"\",\n  \"customerId\": \"\",\n  \"eci\": 0,\n  \"enrolled\": \"\",\n  \"enrollmentEci\": \"\",\n  \"gatewayAccountId\": \"\",\n  \"id\": \"\",\n  \"payerAuthResponseStatus\": \"\",\n  \"paymentCardId\": \"\",\n  \"signatureVerification\": \"\",\n  \"websiteId\": \"\",\n  \"xid\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "amount": "",
        "cavv": "",
        "createdTime": "",
        "currency": "",
        "customerId": "",
        "eci": 0,
        "enrolled": "",
        "enrollmentEci": "",
        "gatewayAccountId": "",
        "id": "",
        "payerAuthResponseStatus": "",
        "paymentCardId": "",
        "signatureVerification": "",
        "websiteId": "",
        "xid": ""
    });

    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 '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "amount": "",
  "cavv": "",
  "createdTime": "",
  "currency": "",
  "customerId": "",
  "eci": 0,
  "enrolled": "",
  "enrollmentEci": "",
  "gatewayAccountId": "",
  "id": "",
  "payerAuthResponseStatus": "",
  "paymentCardId": "",
  "signatureVerification": "",
  "websiteId": "",
  "xid": ""
}' |  \
  http POST {{baseUrl}}/3dsecure \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "amount": "",\n  "cavv": "",\n  "createdTime": "",\n  "currency": "",\n  "customerId": "",\n  "eci": 0,\n  "enrolled": "",\n  "enrollmentEci": "",\n  "gatewayAccountId": "",\n  "id": "",\n  "payerAuthResponseStatus": "",\n  "paymentCardId": "",\n  "signatureVerification": "",\n  "websiteId": "",\n  "xid": ""\n}' \
  --output-document \
  - {{baseUrl}}/3dsecure

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "amount": "",
  "cavv": "",
  "createdTime": "",
  "currency": "",
  "customerId": "",
  "eci": 0,
  "enrolled": "",
  "enrollmentEci": "",
  "gatewayAccountId": "",
  "id": "",
  "payerAuthResponseStatus": "",
  "paymentCardId": "",
  "signatureVerification": "",
  "websiteId": "",
  "xid": ""
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/3dsecure/:id")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/3dsecure/: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/3dsecure/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/3dsecure/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/3dsecure/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/3dsecure/: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/3dsecure/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/3dsecure/: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}}/3dsecure/:id

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/3dsecure")

require "http/client"

url = "{{baseUrl}}/3dsecure"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/3dsecure"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/3dsecure")

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

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

import requests

url = "{{baseUrl}}/3dsecure"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/3dsecure"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/3dsecure")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/3dsecure

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/3dsecure")! 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}}/aml?firstName=&lastName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/aml" {:query-params {:firstName ""
                                                              :lastName ""}})

require "http/client"

url = "{{baseUrl}}/aml?firstName=&lastName="

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

var client = new RestClient("{{baseUrl}}/aml?firstName=&lastName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/aml?firstName=&lastName="

	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/aml?firstName=&lastName= HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/aml?firstName=&lastName=")
  .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}}/aml?firstName=&lastName=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/aml',
  params: {firstName: '', lastName: ''}
};

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

const url = '{{baseUrl}}/aml?firstName=&lastName=';
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}}/aml?firstName=&lastName=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/aml?firstName=&lastName=")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

req.query({
  firstName: '',
  lastName: ''
});

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}}/aml',
  params: {firstName: '', lastName: ''}
};

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

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

const url = '{{baseUrl}}/aml?firstName=&lastName=';
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}}/aml?firstName=&lastName="]
                                                       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}}/aml?firstName=&lastName=" in

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

 "{{baseUrl}}/aml?firstName=&lastName=",
  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}}/aml?firstName=&lastName=');

echo $response->getBody();

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

$request->setQueryData([
  'firstName' => '',
  'lastName' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/aml');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'firstName' => '',
  'lastName' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/aml?firstName=&lastName=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/aml?firstName=&lastName=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/aml?firstName=&lastName=")

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

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

import requests

url = "{{baseUrl}}/aml"

querystring = {"firstName":"","lastName":""}

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

print(response.json())

library(httr)

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

queryString <- list(
  firstName = "",
  lastName = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/aml?firstName=&lastName=")

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/aml') do |req|
  req.params['firstName'] = ''
  req.params['lastName'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("firstName", ""),
        ("lastName", ""),
    ];

    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}}/aml?firstName=&lastName='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/aml?firstName=&lastName='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/aml?firstName=&lastName=")! 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}}/bank-accounts/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/bank-accounts/:id")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/bank-accounts/:id");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bank-accounts/: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/bank-accounts/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/bank-accounts/:id'};

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

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

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

val client = OkHttpClient()

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

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/bank-accounts/:id');
$request->setMethod(HTTP_METH_PUT);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bank-accounts/:id' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bank-accounts/:id' -Method PUT 

import http.client

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

conn.request("PUT", "/baseUrl/bank-accounts/:id")

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

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

import requests

url = "{{baseUrl}}/bank-accounts/:id"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bank-accounts/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bank-accounts/: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/bank-accounts/: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}}/bank-accounts/: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}}/bank-accounts/:id

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bank-accounts/:id

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/bank-accounts")

require "http/client"

url = "{{baseUrl}}/bank-accounts"

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

var client = new RestClient("{{baseUrl}}/bank-accounts");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bank-accounts"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/bank-accounts'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bank-accounts")
  .post(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bank-accounts');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bank-accounts' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bank-accounts' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/bank-accounts")

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

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

import requests

url = "{{baseUrl}}/bank-accounts"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bank-accounts"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bank-accounts")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/bank-accounts

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bank-accounts

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/bank-accounts/:id/deactivation")

require "http/client"

url = "{{baseUrl}}/bank-accounts/:id/deactivation"

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

var client = new RestClient("{{baseUrl}}/bank-accounts/:id/deactivation");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bank-accounts/:id/deactivation"

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

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bank-accounts/:id/deactivation")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bank-accounts/:id/deactivation"))
    .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}}/bank-accounts/:id/deactivation")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/bank-accounts/:id/deactivation")
  .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}}/bank-accounts/:id/deactivation');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bank-accounts/:id/deactivation'
};

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

const url = '{{baseUrl}}/bank-accounts/:id/deactivation';
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}}/bank-accounts/:id/deactivation',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bank-accounts/:id/deactivation")
  .post(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bank-accounts/:id/deactivation');

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}}/bank-accounts/:id/deactivation'
};

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/bank-accounts/:id/deactivation');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/bank-accounts/:id/deactivation');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bank-accounts/:id/deactivation' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bank-accounts/:id/deactivation' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/bank-accounts/:id/deactivation")

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

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

import requests

url = "{{baseUrl}}/bank-accounts/:id/deactivation"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bank-accounts/:id/deactivation"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bank-accounts/:id/deactivation")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/bank-accounts/:id/deactivation

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bank-accounts/:id/deactivation

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bank-accounts/:id")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/bank-accounts/: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/bank-accounts/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/bank-accounts/:id'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/bank-accounts/:id")

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

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

import requests

url = "{{baseUrl}}/bank-accounts/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bank-accounts/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bank-accounts/: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/bank-accounts/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bank-accounts/: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}}/bank-accounts/:id

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bank-accounts")

require "http/client"

url = "{{baseUrl}}/bank-accounts"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/bank-accounts"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/bank-accounts'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bank-accounts');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/bank-accounts")

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

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

import requests

url = "{{baseUrl}}/bank-accounts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bank-accounts"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bank-accounts")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/bank-accounts

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bank-accounts")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bank-accounts/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"customFields\": {\n    \"foo\": \"bar\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/bank-accounts/:id" {:content-type :json
                                                               :form-params {:customFields {:foo "bar"}}})

require "http/client"

url = "{{baseUrl}}/bank-accounts/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customFields\": {\n    \"foo\": \"bar\"\n  }\n}"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/bank-accounts/:id"

	payload := strings.NewReader("{\n  \"customFields\": {\n    \"foo\": \"bar\"\n  }\n}")

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

}

PATCH /baseUrl/bank-accounts/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "customFields": {
    "foo": "bar"
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/bank-accounts/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customFields\": {\n    \"foo\": \"bar\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bank-accounts/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"customFields\": {\n    \"foo\": \"bar\"\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  \"customFields\": {\n    \"foo\": \"bar\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/bank-accounts/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/bank-accounts/:id")
  .header("content-type", "application/json")
  .body("{\n  \"customFields\": {\n    \"foo\": \"bar\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  customFields: {
    foo: 'bar'
  }
});

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

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

xhr.open('PATCH', '{{baseUrl}}/bank-accounts/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/bank-accounts/:id',
  headers: {'content-type': 'application/json'},
  data: {customFields: {foo: 'bar'}}
};

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

const url = '{{baseUrl}}/bank-accounts/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"customFields":{"foo":"bar"}}'
};

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}}/bank-accounts/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customFields": {\n    "foo": "bar"\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  \"customFields\": {\n    \"foo\": \"bar\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/bank-accounts/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({customFields: {foo: 'bar'}}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/bank-accounts/:id',
  headers: {'content-type': 'application/json'},
  body: {customFields: {foo: 'bar'}},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/bank-accounts/:id');

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

req.type('json');
req.send({
  customFields: {
    foo: 'bar'
  }
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/bank-accounts/:id',
  headers: {'content-type': 'application/json'},
  data: {customFields: {foo: 'bar'}}
};

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

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

const url = '{{baseUrl}}/bank-accounts/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"customFields":{"foo":"bar"}}'
};

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 = @{ @"customFields": @{ @"foo": @"bar" } };

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/bank-accounts/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

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

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

append(json_encode([
  'customFields' => [
    'foo' => 'bar'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/bank-accounts/:id');
$request->setRequestMethod('PATCH');
$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}}/bank-accounts/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "customFields": {
    "foo": "bar"
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bank-accounts/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "customFields": {
    "foo": "bar"
  }
}'

import http.client

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

payload = "{\n  \"customFields\": {\n    \"foo\": \"bar\"\n  }\n}"

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

conn.request("PATCH", "/baseUrl/bank-accounts/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/bank-accounts/:id"

payload = { "customFields": { "foo": "bar" } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/bank-accounts/:id"

payload <- "{\n  \"customFields\": {\n    \"foo\": \"bar\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bank-accounts/:id")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"customFields\": {\n    \"foo\": \"bar\"\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.patch('/baseUrl/bank-accounts/:id') do |req|
  req.body = "{\n  \"customFields\": {\n    \"foo\": \"bar\"\n  }\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}}/bank-accounts/:id";

    let payload = json!({"customFields": json!({"foo": "bar"})});

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

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

    dbg!(results);
}

echo '{
  "customFields": {
    "foo": "bar"
  }
}' |  \
  http PATCH {{baseUrl}}/bank-accounts/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "customFields": {\n    "foo": "bar"\n  }\n}' \
  --output-document \
  - {{baseUrl}}/bank-accounts/:id

import Foundation

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

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/blocklists/:id" {:content-type :json
                                                          :form-params {:_links [{:rel ""}]
                                                                        :createdTime ""
                                                                        :expirationTime ""
                                                                        :id ""
                                                                        :type ""
                                                                        :updatedTime ""
                                                                        :value ""}})

require "http/client"

url = "{{baseUrl}}/blocklists/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\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}}/blocklists/:id"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/blocklists/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\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/blocklists/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 156

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/blocklists/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/blocklists/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/blocklists/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/blocklists/:id")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  expirationTime: '',
  id: '',
  type: '',
  updatedTime: '',
  value: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/blocklists/:id',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    createdTime: '',
    expirationTime: '',
    id: '',
    type: '',
    updatedTime: '',
    value: ''
  }
};

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

const url = '{{baseUrl}}/blocklists/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","expirationTime":"","id":"","type":"","updatedTime":"","value":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/blocklists/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "expirationTime": "",\n  "id": "",\n  "type": "",\n  "updatedTime": "",\n  "value": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/blocklists/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  _links: [{rel: ''}],
  createdTime: '',
  expirationTime: '',
  id: '',
  type: '',
  updatedTime: '',
  value: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/blocklists/:id',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [{rel: ''}],
    createdTime: '',
    expirationTime: '',
    id: '',
    type: '',
    updatedTime: '',
    value: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/blocklists/:id');

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

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  expirationTime: '',
  id: '',
  type: '',
  updatedTime: '',
  value: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/blocklists/:id',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    createdTime: '',
    expirationTime: '',
    id: '',
    type: '',
    updatedTime: '',
    value: ''
  }
};

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

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

const url = '{{baseUrl}}/blocklists/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","expirationTime":"","id":"","type":"","updatedTime":"","value":""}'
};

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 = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"createdTime": @"",
                              @"expirationTime": @"",
                              @"id": @"",
                              @"type": @"",
                              @"updatedTime": @"",
                              @"value": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/blocklists/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/blocklists/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}" in

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

 "{{baseUrl}}/blocklists/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'createdTime' => '',
    'expirationTime' => '',
    'id' => '',
    'type' => '',
    'updatedTime' => '',
    'value' => ''
  ]),
  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}}/blocklists/:id', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'expirationTime' => '',
  'id' => '',
  'type' => '',
  'updatedTime' => '',
  'value' => ''
]));

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

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

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'expirationTime' => '',
  'id' => '',
  'type' => '',
  'updatedTime' => '',
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/blocklists/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/blocklists/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/blocklists/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}'

import http.client

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

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/blocklists/:id", payload, headers)

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

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

import requests

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

payload = {
    "_links": [{ "rel": "" }],
    "createdTime": "",
    "expirationTime": "",
    "id": "",
    "type": "",
    "updatedTime": "",
    "value": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\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}}/blocklists/:id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/blocklists/:id') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\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}}/blocklists/:id";

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "createdTime": "",
        "expirationTime": "",
        "id": "",
        "type": "",
        "updatedTime": "",
        "value": ""
    });

    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 '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}' |  \
  http PUT {{baseUrl}}/blocklists/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "expirationTime": "",\n  "id": "",\n  "type": "",\n  "updatedTime": "",\n  "value": ""\n}' \
  --output-document \
  - {{baseUrl}}/blocklists/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/blocklists" {:content-type :json
                                                       :form-params {:_links [{:rel ""}]
                                                                     :createdTime ""
                                                                     :expirationTime ""
                                                                     :id ""
                                                                     :type ""
                                                                     :updatedTime ""
                                                                     :value ""}})

require "http/client"

url = "{{baseUrl}}/blocklists"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/blocklists"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/blocklists");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\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/blocklists HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 156

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/blocklists")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/blocklists"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/blocklists")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/blocklists")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  expirationTime: '',
  id: '',
  type: '',
  updatedTime: '',
  value: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/blocklists',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    createdTime: '',
    expirationTime: '',
    id: '',
    type: '',
    updatedTime: '',
    value: ''
  }
};

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

const url = '{{baseUrl}}/blocklists';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","expirationTime":"","id":"","type":"","updatedTime":"","value":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/blocklists',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "expirationTime": "",\n  "id": "",\n  "type": "",\n  "updatedTime": "",\n  "value": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/blocklists")
  .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/blocklists',
  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({
  _links: [{rel: ''}],
  createdTime: '',
  expirationTime: '',
  id: '',
  type: '',
  updatedTime: '',
  value: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/blocklists',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [{rel: ''}],
    createdTime: '',
    expirationTime: '',
    id: '',
    type: '',
    updatedTime: '',
    value: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  expirationTime: '',
  id: '',
  type: '',
  updatedTime: '',
  value: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/blocklists',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    createdTime: '',
    expirationTime: '',
    id: '',
    type: '',
    updatedTime: '',
    value: ''
  }
};

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

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

const url = '{{baseUrl}}/blocklists';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","expirationTime":"","id":"","type":"","updatedTime":"","value":""}'
};

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 = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"createdTime": @"",
                              @"expirationTime": @"",
                              @"id": @"",
                              @"type": @"",
                              @"updatedTime": @"",
                              @"value": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/blocklists"]
                                                       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}}/blocklists" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}" in

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

 "{{baseUrl}}/blocklists",
  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([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'createdTime' => '',
    'expirationTime' => '',
    'id' => '',
    'type' => '',
    'updatedTime' => '',
    'value' => ''
  ]),
  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}}/blocklists', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'expirationTime' => '',
  'id' => '',
  'type' => '',
  'updatedTime' => '',
  'value' => ''
]));

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

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

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'expirationTime' => '',
  'id' => '',
  'type' => '',
  'updatedTime' => '',
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/blocklists');
$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}}/blocklists' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/blocklists' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}'

import http.client

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

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/blocklists"

payload = {
    "_links": [{ "rel": "" }],
    "createdTime": "",
    "expirationTime": "",
    "id": "",
    "type": "",
    "updatedTime": "",
    "value": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\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}}/blocklists")

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/blocklists') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\",\n  \"value\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "createdTime": "",
        "expirationTime": "",
        "id": "",
        "type": "",
        "updatedTime": "",
        "value": ""
    });

    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 '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
}' |  \
  http POST {{baseUrl}}/blocklists \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "expirationTime": "",\n  "id": "",\n  "type": "",\n  "updatedTime": "",\n  "value": ""\n}' \
  --output-document \
  - {{baseUrl}}/blocklists

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "createdTime": "",
  "expirationTime": "",
  "id": "",
  "type": "",
  "updatedTime": "",
  "value": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/blocklists/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/blocklists/:id")

require "http/client"

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

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/blocklists/:id'};

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

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

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

val client = OkHttpClient()

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/blocklists/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/blocklists/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/blocklists/:id")

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/blocklists/: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/blocklists/: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}}/blocklists/: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}}/blocklists/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/blocklists/:id

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/blocklists/: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/blocklists/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/blocklists/: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}}/blocklists/:id

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/blocklists"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/blocklists"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/blocklists

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/blocklists")! 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}}/coupons-redemptions/:id/cancel");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/coupons-redemptions/:id/cancel")

require "http/client"

url = "{{baseUrl}}/coupons-redemptions/:id/cancel"

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

var client = new RestClient("{{baseUrl}}/coupons-redemptions/:id/cancel");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/coupons-redemptions/:id/cancel"

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

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/coupons-redemptions/:id/cancel")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/coupons-redemptions/:id/cancel"))
    .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}}/coupons-redemptions/:id/cancel")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/coupons-redemptions/:id/cancel")
  .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}}/coupons-redemptions/:id/cancel');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/coupons-redemptions/:id/cancel'
};

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

const url = '{{baseUrl}}/coupons-redemptions/:id/cancel';
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}}/coupons-redemptions/:id/cancel',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/coupons-redemptions/:id/cancel")
  .post(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/coupons-redemptions/:id/cancel');

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}}/coupons-redemptions/:id/cancel'
};

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/coupons-redemptions/:id/cancel');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/coupons-redemptions/:id/cancel');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/coupons-redemptions/:id/cancel' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/coupons-redemptions/:id/cancel' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/coupons-redemptions/:id/cancel")

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

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

import requests

url = "{{baseUrl}}/coupons-redemptions/:id/cancel"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/coupons-redemptions/:id/cancel"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/coupons-redemptions/:id/cancel")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/coupons-redemptions/:id/cancel

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/coupons-redemptions/:id/cancel

import Foundation

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

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/coupons" {:content-type :json
                                                    :form-params {:_links [{:rel ""}]
                                                                  :createdTime ""
                                                                  :description ""
                                                                  :discount {:type ""}
                                                                  :expiredTime ""
                                                                  :id ""
                                                                  :issuedTime ""
                                                                  :redemptionsCount 0
                                                                  :restrictions [{:type ""}]
                                                                  :status ""
                                                                  :updatedTime ""}})

require "http/client"

url = "{{baseUrl}}/coupons"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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}}/coupons"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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}}/coupons");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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/coupons HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 296

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/coupons")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/coupons"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/coupons")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/coupons")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  description: '',
  discount: {
    type: ''
  },
  expiredTime: '',
  id: '',
  issuedTime: '',
  redemptionsCount: 0,
  restrictions: [
    {
      type: ''
    }
  ],
  status: '',
  updatedTime: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/coupons',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    createdTime: '',
    description: '',
    discount: {type: ''},
    expiredTime: '',
    id: '',
    issuedTime: '',
    redemptionsCount: 0,
    restrictions: [{type: ''}],
    status: '',
    updatedTime: ''
  }
};

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

const url = '{{baseUrl}}/coupons';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","description":"","discount":{"type":""},"expiredTime":"","id":"","issuedTime":"","redemptionsCount":0,"restrictions":[{"type":""}],"status":"","updatedTime":""}'
};

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}}/coupons',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "description": "",\n  "discount": {\n    "type": ""\n  },\n  "expiredTime": "",\n  "id": "",\n  "issuedTime": "",\n  "redemptionsCount": 0,\n  "restrictions": [\n    {\n      "type": ""\n    }\n  ],\n  "status": "",\n  "updatedTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/coupons")
  .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/coupons',
  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({
  _links: [{rel: ''}],
  createdTime: '',
  description: '',
  discount: {type: ''},
  expiredTime: '',
  id: '',
  issuedTime: '',
  redemptionsCount: 0,
  restrictions: [{type: ''}],
  status: '',
  updatedTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/coupons',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [{rel: ''}],
    createdTime: '',
    description: '',
    discount: {type: ''},
    expiredTime: '',
    id: '',
    issuedTime: '',
    redemptionsCount: 0,
    restrictions: [{type: ''}],
    status: '',
    updatedTime: ''
  },
  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}}/coupons');

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

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  description: '',
  discount: {
    type: ''
  },
  expiredTime: '',
  id: '',
  issuedTime: '',
  redemptionsCount: 0,
  restrictions: [
    {
      type: ''
    }
  ],
  status: '',
  updatedTime: ''
});

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}}/coupons',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    createdTime: '',
    description: '',
    discount: {type: ''},
    expiredTime: '',
    id: '',
    issuedTime: '',
    redemptionsCount: 0,
    restrictions: [{type: ''}],
    status: '',
    updatedTime: ''
  }
};

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

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

const url = '{{baseUrl}}/coupons';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","description":"","discount":{"type":""},"expiredTime":"","id":"","issuedTime":"","redemptionsCount":0,"restrictions":[{"type":""}],"status":"","updatedTime":""}'
};

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 = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"createdTime": @"",
                              @"description": @"",
                              @"discount": @{ @"type": @"" },
                              @"expiredTime": @"",
                              @"id": @"",
                              @"issuedTime": @"",
                              @"redemptionsCount": @0,
                              @"restrictions": @[ @{ @"type": @"" } ],
                              @"status": @"",
                              @"updatedTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/coupons"]
                                                       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}}/coupons" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}" in

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

 "{{baseUrl}}/coupons",
  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([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'createdTime' => '',
    'description' => '',
    'discount' => [
        'type' => ''
    ],
    'expiredTime' => '',
    'id' => '',
    'issuedTime' => '',
    'redemptionsCount' => 0,
    'restrictions' => [
        [
                'type' => ''
        ]
    ],
    'status' => '',
    'updatedTime' => ''
  ]),
  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}}/coupons', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'description' => '',
  'discount' => [
    'type' => ''
  ],
  'expiredTime' => '',
  'id' => '',
  'issuedTime' => '',
  'redemptionsCount' => 0,
  'restrictions' => [
    [
        'type' => ''
    ]
  ],
  'status' => '',
  'updatedTime' => ''
]));

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

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

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'description' => '',
  'discount' => [
    'type' => ''
  ],
  'expiredTime' => '',
  'id' => '',
  'issuedTime' => '',
  'redemptionsCount' => 0,
  'restrictions' => [
    [
        'type' => ''
    ]
  ],
  'status' => '',
  'updatedTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/coupons');
$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}}/coupons' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/coupons' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}'

import http.client

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

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/coupons"

payload = {
    "_links": [{ "rel": "" }],
    "createdTime": "",
    "description": "",
    "discount": { "type": "" },
    "expiredTime": "",
    "id": "",
    "issuedTime": "",
    "redemptionsCount": 0,
    "restrictions": [{ "type": "" }],
    "status": "",
    "updatedTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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}}/coupons")

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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/coupons') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "createdTime": "",
        "description": "",
        "discount": json!({"type": ""}),
        "expiredTime": "",
        "id": "",
        "issuedTime": "",
        "redemptionsCount": 0,
        "restrictions": (json!({"type": ""})),
        "status": "",
        "updatedTime": ""
    });

    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 '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}' |  \
  http POST {{baseUrl}}/coupons \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "description": "",\n  "discount": {\n    "type": ""\n  },\n  "expiredTime": "",\n  "id": "",\n  "issuedTime": "",\n  "redemptionsCount": 0,\n  "restrictions": [\n    {\n      "type": ""\n    }\n  ],\n  "status": "",\n  "updatedTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/coupons

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "createdTime": "",
  "description": "",
  "discount": ["type": ""],
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [["type": ""]],
  "status": "",
  "updatedTime": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/coupons/:id" {:content-type :json
                                                       :form-params {:_links [{:rel ""}]
                                                                     :createdTime ""
                                                                     :description ""
                                                                     :discount {:type ""}
                                                                     :expiredTime ""
                                                                     :id ""
                                                                     :issuedTime ""
                                                                     :redemptionsCount 0
                                                                     :restrictions [{:type ""}]
                                                                     :status ""
                                                                     :updatedTime ""}})

require "http/client"

url = "{{baseUrl}}/coupons/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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}}/coupons/:id"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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}}/coupons/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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/coupons/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 296

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/coupons/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/coupons/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/coupons/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/coupons/:id")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  description: '',
  discount: {
    type: ''
  },
  expiredTime: '',
  id: '',
  issuedTime: '',
  redemptionsCount: 0,
  restrictions: [
    {
      type: ''
    }
  ],
  status: '',
  updatedTime: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/coupons/:id',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    createdTime: '',
    description: '',
    discount: {type: ''},
    expiredTime: '',
    id: '',
    issuedTime: '',
    redemptionsCount: 0,
    restrictions: [{type: ''}],
    status: '',
    updatedTime: ''
  }
};

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

const url = '{{baseUrl}}/coupons/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","description":"","discount":{"type":""},"expiredTime":"","id":"","issuedTime":"","redemptionsCount":0,"restrictions":[{"type":""}],"status":"","updatedTime":""}'
};

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}}/coupons/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "description": "",\n  "discount": {\n    "type": ""\n  },\n  "expiredTime": "",\n  "id": "",\n  "issuedTime": "",\n  "redemptionsCount": 0,\n  "restrictions": [\n    {\n      "type": ""\n    }\n  ],\n  "status": "",\n  "updatedTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/coupons/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  _links: [{rel: ''}],
  createdTime: '',
  description: '',
  discount: {type: ''},
  expiredTime: '',
  id: '',
  issuedTime: '',
  redemptionsCount: 0,
  restrictions: [{type: ''}],
  status: '',
  updatedTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/coupons/:id',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [{rel: ''}],
    createdTime: '',
    description: '',
    discount: {type: ''},
    expiredTime: '',
    id: '',
    issuedTime: '',
    redemptionsCount: 0,
    restrictions: [{type: ''}],
    status: '',
    updatedTime: ''
  },
  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}}/coupons/:id');

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

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  description: '',
  discount: {
    type: ''
  },
  expiredTime: '',
  id: '',
  issuedTime: '',
  redemptionsCount: 0,
  restrictions: [
    {
      type: ''
    }
  ],
  status: '',
  updatedTime: ''
});

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}}/coupons/:id',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    createdTime: '',
    description: '',
    discount: {type: ''},
    expiredTime: '',
    id: '',
    issuedTime: '',
    redemptionsCount: 0,
    restrictions: [{type: ''}],
    status: '',
    updatedTime: ''
  }
};

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

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

const url = '{{baseUrl}}/coupons/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","description":"","discount":{"type":""},"expiredTime":"","id":"","issuedTime":"","redemptionsCount":0,"restrictions":[{"type":""}],"status":"","updatedTime":""}'
};

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 = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"createdTime": @"",
                              @"description": @"",
                              @"discount": @{ @"type": @"" },
                              @"expiredTime": @"",
                              @"id": @"",
                              @"issuedTime": @"",
                              @"redemptionsCount": @0,
                              @"restrictions": @[ @{ @"type": @"" } ],
                              @"status": @"",
                              @"updatedTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/coupons/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/coupons/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}" in

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

 "{{baseUrl}}/coupons/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'createdTime' => '',
    'description' => '',
    'discount' => [
        'type' => ''
    ],
    'expiredTime' => '',
    'id' => '',
    'issuedTime' => '',
    'redemptionsCount' => 0,
    'restrictions' => [
        [
                'type' => ''
        ]
    ],
    'status' => '',
    'updatedTime' => ''
  ]),
  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}}/coupons/:id', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'description' => '',
  'discount' => [
    'type' => ''
  ],
  'expiredTime' => '',
  'id' => '',
  'issuedTime' => '',
  'redemptionsCount' => 0,
  'restrictions' => [
    [
        'type' => ''
    ]
  ],
  'status' => '',
  'updatedTime' => ''
]));

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

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

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'description' => '',
  'discount' => [
    'type' => ''
  ],
  'expiredTime' => '',
  'id' => '',
  'issuedTime' => '',
  'redemptionsCount' => 0,
  'restrictions' => [
    [
        'type' => ''
    ]
  ],
  'status' => '',
  'updatedTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/coupons/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/coupons/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/coupons/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}'

import http.client

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

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/coupons/:id", payload, headers)

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

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

import requests

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

payload = {
    "_links": [{ "rel": "" }],
    "createdTime": "",
    "description": "",
    "discount": { "type": "" },
    "expiredTime": "",
    "id": "",
    "issuedTime": "",
    "redemptionsCount": 0,
    "restrictions": [{ "type": "" }],
    "status": "",
    "updatedTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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}}/coupons/:id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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/coupons/:id') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"description\": \"\",\n  \"discount\": {\n    \"type\": \"\"\n  },\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"issuedTime\": \"\",\n  \"redemptionsCount\": 0,\n  \"restrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"status\": \"\",\n  \"updatedTime\": \"\"\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}}/coupons/:id";

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "createdTime": "",
        "description": "",
        "discount": json!({"type": ""}),
        "expiredTime": "",
        "id": "",
        "issuedTime": "",
        "redemptionsCount": 0,
        "restrictions": (json!({"type": ""})),
        "status": "",
        "updatedTime": ""
    });

    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 '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "description": "",
  "discount": {
    "type": ""
  },
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [
    {
      "type": ""
    }
  ],
  "status": "",
  "updatedTime": ""
}' |  \
  http PUT {{baseUrl}}/coupons/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "description": "",\n  "discount": {\n    "type": ""\n  },\n  "expiredTime": "",\n  "id": "",\n  "issuedTime": "",\n  "redemptionsCount": 0,\n  "restrictions": [\n    {\n      "type": ""\n    }\n  ],\n  "status": "",\n  "updatedTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/coupons/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "createdTime": "",
  "description": "",
  "discount": ["type": ""],
  "expiredTime": "",
  "id": "",
  "issuedTime": "",
  "redemptionsCount": 0,
  "restrictions": [["type": ""]],
  "status": "",
  "updatedTime": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/coupons-redemptions");

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/coupons-redemptions" {:content-type :json
                                                                :form-params {:_links [{:rel ""}]
                                                                              :additionalRestrictions [{:type ""}]
                                                                              :canceledTime ""
                                                                              :couponId ""
                                                                              :createdTime ""
                                                                              :customerId ""
                                                                              :id ""}})

require "http/client"

url = "{{baseUrl}}/coupons-redemptions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/coupons-redemptions"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/coupons-redemptions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/coupons-redemptions"

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\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/coupons-redemptions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 206

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalRestrictions": [
    {
      "type": ""
    }
  ],
  "canceledTime": "",
  "couponId": "",
  "createdTime": "",
  "customerId": "",
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/coupons-redemptions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/coupons-redemptions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/coupons-redemptions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/coupons-redemptions")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  additionalRestrictions: [
    {
      type: ''
    }
  ],
  canceledTime: '',
  couponId: '',
  createdTime: '',
  customerId: '',
  id: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/coupons-redemptions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/coupons-redemptions',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    additionalRestrictions: [{type: ''}],
    canceledTime: '',
    couponId: '',
    createdTime: '',
    customerId: '',
    id: ''
  }
};

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

const url = '{{baseUrl}}/coupons-redemptions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"additionalRestrictions":[{"type":""}],"canceledTime":"","couponId":"","createdTime":"","customerId":"","id":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/coupons-redemptions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "additionalRestrictions": [\n    {\n      "type": ""\n    }\n  ],\n  "canceledTime": "",\n  "couponId": "",\n  "createdTime": "",\n  "customerId": "",\n  "id": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/coupons-redemptions")
  .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/coupons-redemptions',
  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({
  _links: [{rel: ''}],
  additionalRestrictions: [{type: ''}],
  canceledTime: '',
  couponId: '',
  createdTime: '',
  customerId: '',
  id: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/coupons-redemptions',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [{rel: ''}],
    additionalRestrictions: [{type: ''}],
    canceledTime: '',
    couponId: '',
    createdTime: '',
    customerId: '',
    id: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/coupons-redemptions');

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

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  additionalRestrictions: [
    {
      type: ''
    }
  ],
  canceledTime: '',
  couponId: '',
  createdTime: '',
  customerId: '',
  id: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/coupons-redemptions',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    additionalRestrictions: [{type: ''}],
    canceledTime: '',
    couponId: '',
    createdTime: '',
    customerId: '',
    id: ''
  }
};

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

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

const url = '{{baseUrl}}/coupons-redemptions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"additionalRestrictions":[{"type":""}],"canceledTime":"","couponId":"","createdTime":"","customerId":"","id":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"additionalRestrictions": @[ @{ @"type": @"" } ],
                              @"canceledTime": @"",
                              @"couponId": @"",
                              @"createdTime": @"",
                              @"customerId": @"",
                              @"id": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/coupons-redemptions"]
                                                       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}}/coupons-redemptions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}" in

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

 "{{baseUrl}}/coupons-redemptions",
  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([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'additionalRestrictions' => [
        [
                'type' => ''
        ]
    ],
    'canceledTime' => '',
    'couponId' => '',
    'createdTime' => '',
    'customerId' => '',
    'id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/coupons-redemptions', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalRestrictions": [
    {
      "type": ""
    }
  ],
  "canceledTime": "",
  "couponId": "",
  "createdTime": "",
  "customerId": "",
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'additionalRestrictions' => [
    [
        'type' => ''
    ]
  ],
  'canceledTime' => '',
  'couponId' => '',
  'createdTime' => '',
  'customerId' => '',
  'id' => ''
]));

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

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

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'additionalRestrictions' => [
    [
        'type' => ''
    ]
  ],
  'canceledTime' => '',
  'couponId' => '',
  'createdTime' => '',
  'customerId' => '',
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/coupons-redemptions');
$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}}/coupons-redemptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalRestrictions": [
    {
      "type": ""
    }
  ],
  "canceledTime": "",
  "couponId": "",
  "createdTime": "",
  "customerId": "",
  "id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/coupons-redemptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalRestrictions": [
    {
      "type": ""
    }
  ],
  "canceledTime": "",
  "couponId": "",
  "createdTime": "",
  "customerId": "",
  "id": ""
}'

import http.client

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

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}"

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

conn.request("POST", "/baseUrl/coupons-redemptions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/coupons-redemptions"

payload = {
    "_links": [{ "rel": "" }],
    "additionalRestrictions": [{ "type": "" }],
    "canceledTime": "",
    "couponId": "",
    "createdTime": "",
    "customerId": "",
    "id": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/coupons-redemptions"

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\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}}/coupons-redemptions")

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/coupons-redemptions') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalRestrictions\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"canceledTime\": \"\",\n  \"couponId\": \"\",\n  \"createdTime\": \"\",\n  \"customerId\": \"\",\n  \"id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "additionalRestrictions": (json!({"type": ""})),
        "canceledTime": "",
        "couponId": "",
        "createdTime": "",
        "customerId": "",
        "id": ""
    });

    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 '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalRestrictions": [
    {
      "type": ""
    }
  ],
  "canceledTime": "",
  "couponId": "",
  "createdTime": "",
  "customerId": "",
  "id": ""
}' |  \
  http POST {{baseUrl}}/coupons-redemptions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "additionalRestrictions": [\n    {\n      "type": ""\n    }\n  ],\n  "canceledTime": "",\n  "couponId": "",\n  "createdTime": "",\n  "customerId": "",\n  "id": ""\n}' \
  --output-document \
  - {{baseUrl}}/coupons-redemptions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "additionalRestrictions": [["type": ""]],
  "canceledTime": "",
  "couponId": "",
  "createdTime": "",
  "customerId": "",
  "id": ""
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/coupons-redemptions/:id")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/coupons-redemptions/: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/coupons-redemptions/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/coupons-redemptions/:id'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/coupons-redemptions/:id")

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

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

import requests

url = "{{baseUrl}}/coupons-redemptions/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/coupons-redemptions/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/coupons-redemptions/: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/coupons-redemptions/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/coupons-redemptions/: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}}/coupons-redemptions/:id

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/coupons/: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/coupons/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/coupons/: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}}/coupons/:id

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/coupons-redemptions")

require "http/client"

url = "{{baseUrl}}/coupons-redemptions"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/coupons-redemptions"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/coupons-redemptions'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/coupons-redemptions');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/coupons-redemptions")

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

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

import requests

url = "{{baseUrl}}/coupons-redemptions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/coupons-redemptions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/coupons-redemptions")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/coupons-redemptions

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/coupons"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/coupons"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/coupons

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

import Foundation

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

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  \"expiredTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/coupons/:id/expiration" {:content-type :json
                                                                   :form-params {:expiredTime ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/coupons/:id/expiration"

	payload := strings.NewReader("{\n  \"expiredTime\": \"\"\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/coupons/:id/expiration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "expiredTime": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/coupons/:id/expiration")
  .header("content-type", "application/json")
  .body("{\n  \"expiredTime\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/coupons/:id/expiration',
  headers: {'content-type': 'application/json'},
  data: {expiredTime: ''}
};

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

const url = '{{baseUrl}}/coupons/:id/expiration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"expiredTime":""}'
};

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}}/coupons/:id/expiration',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "expiredTime": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"expiredTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/coupons/:id/expiration")
  .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/coupons/:id/expiration',
  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({expiredTime: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/coupons/:id/expiration',
  headers: {'content-type': 'application/json'},
  body: {expiredTime: ''},
  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}}/coupons/:id/expiration');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  expiredTime: ''
});

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}}/coupons/:id/expiration',
  headers: {'content-type': 'application/json'},
  data: {expiredTime: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/coupons/:id/expiration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"expiredTime":""}'
};

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 = @{ @"expiredTime": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/coupons/:id/expiration"]
                                                       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}}/coupons/:id/expiration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"expiredTime\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/coupons/:id/expiration",
  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([
    'expiredTime' => ''
  ]),
  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}}/coupons/:id/expiration', [
  'body' => '{
  "expiredTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/coupons/:id/expiration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'expiredTime' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'expiredTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/coupons/:id/expiration');
$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}}/coupons/:id/expiration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expiredTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/coupons/:id/expiration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expiredTime": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"expiredTime\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/coupons/:id/expiration", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/coupons/:id/expiration"

payload = { "expiredTime": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/coupons/:id/expiration"

payload <- "{\n  \"expiredTime\": \"\"\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}}/coupons/:id/expiration")

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  \"expiredTime\": \"\"\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/coupons/:id/expiration') do |req|
  req.body = "{\n  \"expiredTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/coupons/:id/expiration";

    let payload = json!({"expiredTime": ""});

    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 '{
  "expiredTime": ""
}' |  \
  http POST {{baseUrl}}/coupons/:id/expiration \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "expiredTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/coupons/:id/expiration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["expiredTime": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/coupons/:id/expiration")! 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}}/custom-fields/:resource/:name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/custom-fields/:resource/:name" {:content-type :json
                                                                         :form-params {:_links [{:rel ""}]
                                                                                       :additionalSchema ""
                                                                                       :description ""
                                                                                       :name ""
                                                                                       :type ""}})

require "http/client"

url = "{{baseUrl}}/custom-fields/:resource/:name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/custom-fields/:resource/:name"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/custom-fields/:resource/:name");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/custom-fields/:resource/:name"

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/custom-fields/:resource/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 124

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalSchema": "",
  "description": "",
  "name": "",
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/custom-fields/:resource/:name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/custom-fields/:resource/:name"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/custom-fields/:resource/:name")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/custom-fields/:resource/:name")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  additionalSchema: '',
  description: '',
  name: '',
  type: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/custom-fields/:resource/:name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/custom-fields/:resource/:name',
  headers: {'content-type': 'application/json'},
  data: {_links: [{rel: ''}], additionalSchema: '', description: '', name: '', type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/custom-fields/:resource/:name';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"additionalSchema":"","description":"","name":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/custom-fields/:resource/:name',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "additionalSchema": "",\n  "description": "",\n  "name": "",\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/custom-fields/:resource/:name")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/custom-fields/:resource/:name',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({_links: [{rel: ''}], additionalSchema: '', description: '', name: '', type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/custom-fields/:resource/:name',
  headers: {'content-type': 'application/json'},
  body: {_links: [{rel: ''}], additionalSchema: '', description: '', name: '', type: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/custom-fields/:resource/:name');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  additionalSchema: '',
  description: '',
  name: '',
  type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/custom-fields/:resource/:name',
  headers: {'content-type': 'application/json'},
  data: {_links: [{rel: ''}], additionalSchema: '', description: '', name: '', type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/custom-fields/:resource/:name';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"additionalSchema":"","description":"","name":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"additionalSchema": @"",
                              @"description": @"",
                              @"name": @"",
                              @"type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/custom-fields/:resource/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/custom-fields/:resource/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/custom-fields/:resource/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'additionalSchema' => '',
    'description' => '',
    'name' => '',
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/custom-fields/:resource/:name', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalSchema": "",
  "description": "",
  "name": "",
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/custom-fields/:resource/:name');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'additionalSchema' => '',
  'description' => '',
  'name' => '',
  'type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'additionalSchema' => '',
  'description' => '',
  'name' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/custom-fields/:resource/:name');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/custom-fields/:resource/:name' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalSchema": "",
  "description": "",
  "name": "",
  "type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/custom-fields/:resource/:name' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalSchema": "",
  "description": "",
  "name": "",
  "type": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/custom-fields/:resource/:name", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/custom-fields/:resource/:name"

payload = {
    "_links": [{ "rel": "" }],
    "additionalSchema": "",
    "description": "",
    "name": "",
    "type": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/custom-fields/:resource/:name"

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/custom-fields/:resource/:name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/custom-fields/:resource/:name') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"additionalSchema\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/custom-fields/:resource/:name";

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "additionalSchema": "",
        "description": "",
        "name": "",
        "type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "additionalSchema": "",
  "description": "",
  "name": "",
  "type": ""
}' |  \
  http PUT {{baseUrl}}/custom-fields/:resource/:name \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "additionalSchema": "",\n  "description": "",\n  "name": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/custom-fields/:resource/:name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "additionalSchema": "",
  "description": "",
  "name": "",
  "type": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/custom-fields/:resource/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/custom-fields/:resource");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/custom-fields/:resource")

require "http/client"

url = "{{baseUrl}}/custom-fields/:resource"

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}}/custom-fields/:resource"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/custom-fields/:resource");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/custom-fields/:resource"

	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/custom-fields/:resource HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/custom-fields/:resource")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/custom-fields/:resource"))
    .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}}/custom-fields/:resource")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/custom-fields/:resource")
  .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}}/custom-fields/:resource');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/custom-fields/:resource'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/custom-fields/:resource';
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}}/custom-fields/:resource',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/custom-fields/:resource")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/custom-fields/:resource',
  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}}/custom-fields/:resource'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/custom-fields/:resource');

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}}/custom-fields/:resource'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/custom-fields/:resource';
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}}/custom-fields/:resource"]
                                                       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}}/custom-fields/:resource" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/custom-fields/:resource",
  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}}/custom-fields/:resource');

echo $response->getBody();

setUrl('{{baseUrl}}/custom-fields/:resource');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/custom-fields/:resource');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/custom-fields/:resource' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/custom-fields/:resource' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/custom-fields/:resource")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/custom-fields/:resource"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/custom-fields/:resource"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/custom-fields/:resource")

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/custom-fields/:resource') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/custom-fields/:resource";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/custom-fields/:resource

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/custom-fields/:resource

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/custom-fields/:resource")! 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}}/custom-fields/:resource/:name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/custom-fields/:resource/:name")

require "http/client"

url = "{{baseUrl}}/custom-fields/:resource/:name"

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}}/custom-fields/:resource/:name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/custom-fields/:resource/:name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/custom-fields/:resource/:name"

	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/custom-fields/:resource/:name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/custom-fields/:resource/:name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/custom-fields/:resource/:name"))
    .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}}/custom-fields/:resource/:name")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/custom-fields/:resource/:name")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/custom-fields/:resource/:name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/custom-fields/:resource/:name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/custom-fields/:resource/:name';
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}}/custom-fields/:resource/:name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/custom-fields/:resource/:name")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/custom-fields/:resource/:name',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/custom-fields/:resource/:name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/custom-fields/:resource/:name');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/custom-fields/:resource/:name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/custom-fields/:resource/:name';
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}}/custom-fields/:resource/:name"]
                                                       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}}/custom-fields/:resource/:name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/custom-fields/:resource/:name",
  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}}/custom-fields/:resource/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/custom-fields/:resource/:name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/custom-fields/:resource/:name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/custom-fields/:resource/:name' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/custom-fields/:resource/:name' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/custom-fields/:resource/:name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/custom-fields/:resource/:name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/custom-fields/:resource/:name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/custom-fields/:resource/:name")

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/custom-fields/:resource/:name') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/custom-fields/:resource/:name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/custom-fields/:resource/:name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/custom-fields/:resource/:name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/custom-fields/:resource/:name")! 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}}/authentication-options");

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  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/authentication-options" {:content-type :json
                                                                  :form-params {:authTokenTtl 0
                                                                                :credentialTtl 0
                                                                                :otpRequired false
                                                                                :passwordPattern ""
                                                                                :resetTokenTtl 0}})

require "http/client"

url = "{{baseUrl}}/authentication-options"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/authentication-options"),
    Content = new StringContent("{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/authentication-options");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/authentication-options"

	payload := strings.NewReader("{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/authentication-options HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 116

{
  "authTokenTtl": 0,
  "credentialTtl": 0,
  "otpRequired": false,
  "passwordPattern": "",
  "resetTokenTtl": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/authentication-options")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication-options"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/authentication-options")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/authentication-options")
  .header("content-type", "application/json")
  .body("{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}")
  .asString();

const data = JSON.stringify({
  authTokenTtl: 0,
  credentialTtl: 0,
  otpRequired: false,
  passwordPattern: '',
  resetTokenTtl: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/authentication-options');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/authentication-options',
  headers: {'content-type': 'application/json'},
  data: {
    authTokenTtl: 0,
    credentialTtl: 0,
    otpRequired: false,
    passwordPattern: '',
    resetTokenTtl: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/authentication-options';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authTokenTtl":0,"credentialTtl":0,"otpRequired":false,"passwordPattern":"","resetTokenTtl":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/authentication-options',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authTokenTtl": 0,\n  "credentialTtl": 0,\n  "otpRequired": false,\n  "passwordPattern": "",\n  "resetTokenTtl": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/authentication-options")
  .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/authentication-options',
  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({
  authTokenTtl: 0,
  credentialTtl: 0,
  otpRequired: false,
  passwordPattern: '',
  resetTokenTtl: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/authentication-options',
  headers: {'content-type': 'application/json'},
  body: {
    authTokenTtl: 0,
    credentialTtl: 0,
    otpRequired: false,
    passwordPattern: '',
    resetTokenTtl: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/authentication-options');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authTokenTtl: 0,
  credentialTtl: 0,
  otpRequired: false,
  passwordPattern: '',
  resetTokenTtl: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/authentication-options',
  headers: {'content-type': 'application/json'},
  data: {
    authTokenTtl: 0,
    credentialTtl: 0,
    otpRequired: false,
    passwordPattern: '',
    resetTokenTtl: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/authentication-options';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authTokenTtl":0,"credentialTtl":0,"otpRequired":false,"passwordPattern":"","resetTokenTtl":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authTokenTtl": @0,
                              @"credentialTtl": @0,
                              @"otpRequired": @NO,
                              @"passwordPattern": @"",
                              @"resetTokenTtl": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authentication-options"]
                                                       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}}/authentication-options" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/authentication-options",
  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([
    'authTokenTtl' => 0,
    'credentialTtl' => 0,
    'otpRequired' => null,
    'passwordPattern' => '',
    'resetTokenTtl' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/authentication-options', [
  'body' => '{
  "authTokenTtl": 0,
  "credentialTtl": 0,
  "otpRequired": false,
  "passwordPattern": "",
  "resetTokenTtl": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/authentication-options');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authTokenTtl' => 0,
  'credentialTtl' => 0,
  'otpRequired' => null,
  'passwordPattern' => '',
  'resetTokenTtl' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authTokenTtl' => 0,
  'credentialTtl' => 0,
  'otpRequired' => null,
  'passwordPattern' => '',
  'resetTokenTtl' => 0
]));
$request->setRequestUrl('{{baseUrl}}/authentication-options');
$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}}/authentication-options' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authTokenTtl": 0,
  "credentialTtl": 0,
  "otpRequired": false,
  "passwordPattern": "",
  "resetTokenTtl": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication-options' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authTokenTtl": 0,
  "credentialTtl": 0,
  "otpRequired": false,
  "passwordPattern": "",
  "resetTokenTtl": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/authentication-options", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/authentication-options"

payload = {
    "authTokenTtl": 0,
    "credentialTtl": 0,
    "otpRequired": False,
    "passwordPattern": "",
    "resetTokenTtl": 0
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication-options"

payload <- "{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication-options")

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  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/authentication-options') do |req|
  req.body = "{\n  \"authTokenTtl\": 0,\n  \"credentialTtl\": 0,\n  \"otpRequired\": false,\n  \"passwordPattern\": \"\",\n  \"resetTokenTtl\": 0\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/authentication-options";

    let payload = json!({
        "authTokenTtl": 0,
        "credentialTtl": 0,
        "otpRequired": false,
        "passwordPattern": "",
        "resetTokenTtl": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "authTokenTtl": 0,
  "credentialTtl": 0,
  "otpRequired": false,
  "passwordPattern": "",
  "resetTokenTtl": 0
}' |  \
  http PUT {{baseUrl}}/authentication-options \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "authTokenTtl": 0,\n  "credentialTtl": 0,\n  "otpRequired": false,\n  "passwordPattern": "",\n  "resetTokenTtl": 0\n}' \
  --output-document \
  - {{baseUrl}}/authentication-options

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authTokenTtl": 0,
  "credentialTtl": 0,
  "otpRequired": false,
  "passwordPattern": "",
  "resetTokenTtl": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authentication-options")! 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}}/password-tokens");

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/password-tokens" {:content-type :json
                                                            :form-params {:_links [{:rel ""}]
                                                                          :credentialId ""
                                                                          :expiredTime ""
                                                                          :token ""
                                                                          :username ""}})

require "http/client"

url = "{{baseUrl}}/password-tokens"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\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}}/password-tokens"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\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}}/password-tokens");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/password-tokens"

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\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/password-tokens HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 125

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "credentialId": "",
  "expiredTime": "",
  "token": "",
  "username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/password-tokens")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/password-tokens"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/password-tokens")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/password-tokens")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  credentialId: '',
  expiredTime: '',
  token: '',
  username: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/password-tokens');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/password-tokens',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    credentialId: '',
    expiredTime: '',
    token: '',
    username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/password-tokens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"credentialId":"","expiredTime":"","token":"","username":""}'
};

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}}/password-tokens',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "credentialId": "",\n  "expiredTime": "",\n  "token": "",\n  "username": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/password-tokens")
  .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/password-tokens',
  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({
  _links: [{rel: ''}],
  credentialId: '',
  expiredTime: '',
  token: '',
  username: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/password-tokens',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [{rel: ''}],
    credentialId: '',
    expiredTime: '',
    token: '',
    username: ''
  },
  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}}/password-tokens');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  credentialId: '',
  expiredTime: '',
  token: '',
  username: ''
});

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}}/password-tokens',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    credentialId: '',
    expiredTime: '',
    token: '',
    username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/password-tokens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"credentialId":"","expiredTime":"","token":"","username":""}'
};

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 = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"credentialId": @"",
                              @"expiredTime": @"",
                              @"token": @"",
                              @"username": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/password-tokens"]
                                                       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}}/password-tokens" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/password-tokens",
  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([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'credentialId' => '',
    'expiredTime' => '',
    'token' => '',
    'username' => ''
  ]),
  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}}/password-tokens', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "credentialId": "",
  "expiredTime": "",
  "token": "",
  "username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/password-tokens');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'credentialId' => '',
  'expiredTime' => '',
  'token' => '',
  'username' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'credentialId' => '',
  'expiredTime' => '',
  'token' => '',
  'username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/password-tokens');
$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}}/password-tokens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "credentialId": "",
  "expiredTime": "",
  "token": "",
  "username": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/password-tokens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "credentialId": "",
  "expiredTime": "",
  "token": "",
  "username": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/password-tokens", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/password-tokens"

payload = {
    "_links": [{ "rel": "" }],
    "credentialId": "",
    "expiredTime": "",
    "token": "",
    "username": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/password-tokens"

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\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}}/password-tokens")

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\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/password-tokens') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"credentialId\": \"\",\n  \"expiredTime\": \"\",\n  \"token\": \"\",\n  \"username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/password-tokens";

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "credentialId": "",
        "expiredTime": "",
        "token": "",
        "username": ""
    });

    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 '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "credentialId": "",
  "expiredTime": "",
  "token": "",
  "username": ""
}' |  \
  http POST {{baseUrl}}/password-tokens \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "credentialId": "",\n  "expiredTime": "",\n  "token": "",\n  "username": ""\n}' \
  --output-document \
  - {{baseUrl}}/password-tokens

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "credentialId": "",
  "expiredTime": "",
  "token": "",
  "username": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/password-tokens")! 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}}/credentials");

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  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/credentials" {:content-type :json
                                                        :form-params {:_links []
                                                                      :customerId ""
                                                                      :expiredTime ""
                                                                      :id ""
                                                                      :password ""
                                                                      :username ""}})

require "http/client"

url = "{{baseUrl}}/credentials"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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}}/credentials"),
    Content = new StringContent("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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}}/credentials");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/credentials"

	payload := strings.NewReader("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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/credentials HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/credentials")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/credentials"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/credentials")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/credentials")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [],
  customerId: '',
  expiredTime: '',
  id: '',
  password: '',
  username: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/credentials');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/credentials',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [],
    customerId: '',
    expiredTime: '',
    id: '',
    password: '',
    username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/credentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[],"customerId":"","expiredTime":"","id":"","password":"","username":""}'
};

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}}/credentials',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [],\n  "customerId": "",\n  "expiredTime": "",\n  "id": "",\n  "password": "",\n  "username": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/credentials")
  .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/credentials',
  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({
  _links: [],
  customerId: '',
  expiredTime: '',
  id: '',
  password: '',
  username: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/credentials',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [],
    customerId: '',
    expiredTime: '',
    id: '',
    password: '',
    username: ''
  },
  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}}/credentials');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _links: [],
  customerId: '',
  expiredTime: '',
  id: '',
  password: '',
  username: ''
});

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}}/credentials',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [],
    customerId: '',
    expiredTime: '',
    id: '',
    password: '',
    username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/credentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[],"customerId":"","expiredTime":"","id":"","password":"","username":""}'
};

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 = @{ @"_links": @[  ],
                              @"customerId": @"",
                              @"expiredTime": @"",
                              @"id": @"",
                              @"password": @"",
                              @"username": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/credentials"]
                                                       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}}/credentials" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/credentials",
  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([
    '_links' => [
        
    ],
    'customerId' => '',
    'expiredTime' => '',
    'id' => '',
    'password' => '',
    'username' => ''
  ]),
  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}}/credentials', [
  'body' => '{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/credentials');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    
  ],
  'customerId' => '',
  'expiredTime' => '',
  'id' => '',
  'password' => '',
  'username' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_links' => [
    
  ],
  'customerId' => '',
  'expiredTime' => '',
  'id' => '',
  'password' => '',
  'username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/credentials');
$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}}/credentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/credentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/credentials", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/credentials"

payload = {
    "_links": [],
    "customerId": "",
    "expiredTime": "",
    "id": "",
    "password": "",
    "username": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/credentials"

payload <- "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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}}/credentials")

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  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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/credentials') do |req|
  req.body = "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/credentials";

    let payload = json!({
        "_links": (),
        "customerId": "",
        "expiredTime": "",
        "id": "",
        "password": "",
        "username": ""
    });

    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 '{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}' |  \
  http POST {{baseUrl}}/credentials \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [],\n  "customerId": "",\n  "expiredTime": "",\n  "id": "",\n  "password": "",\n  "username": ""\n}' \
  --output-document \
  - {{baseUrl}}/credentials

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/credentials")! 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}}/credentials/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/credentials/:id" {:content-type :json
                                                           :form-params {:_links []
                                                                         :customerId ""
                                                                         :expiredTime ""
                                                                         :id ""
                                                                         :password ""
                                                                         :username ""}})

require "http/client"

url = "{{baseUrl}}/credentials/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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}}/credentials/:id"),
    Content = new StringContent("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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}}/credentials/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/credentials/:id"

	payload := strings.NewReader("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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/credentials/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/credentials/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/credentials/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/credentials/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/credentials/:id")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [],
  customerId: '',
  expiredTime: '',
  id: '',
  password: '',
  username: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/credentials/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/credentials/:id',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [],
    customerId: '',
    expiredTime: '',
    id: '',
    password: '',
    username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/credentials/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[],"customerId":"","expiredTime":"","id":"","password":"","username":""}'
};

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}}/credentials/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [],\n  "customerId": "",\n  "expiredTime": "",\n  "id": "",\n  "password": "",\n  "username": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/credentials/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/credentials/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  _links: [],
  customerId: '',
  expiredTime: '',
  id: '',
  password: '',
  username: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/credentials/:id',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [],
    customerId: '',
    expiredTime: '',
    id: '',
    password: '',
    username: ''
  },
  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}}/credentials/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _links: [],
  customerId: '',
  expiredTime: '',
  id: '',
  password: '',
  username: ''
});

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}}/credentials/:id',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [],
    customerId: '',
    expiredTime: '',
    id: '',
    password: '',
    username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/credentials/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[],"customerId":"","expiredTime":"","id":"","password":"","username":""}'
};

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 = @{ @"_links": @[  ],
                              @"customerId": @"",
                              @"expiredTime": @"",
                              @"id": @"",
                              @"password": @"",
                              @"username": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/credentials/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/credentials/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/credentials/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    '_links' => [
        
    ],
    'customerId' => '',
    'expiredTime' => '',
    'id' => '',
    'password' => '',
    'username' => ''
  ]),
  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}}/credentials/:id', [
  'body' => '{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/credentials/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    
  ],
  'customerId' => '',
  'expiredTime' => '',
  'id' => '',
  'password' => '',
  'username' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_links' => [
    
  ],
  'customerId' => '',
  'expiredTime' => '',
  'id' => '',
  'password' => '',
  'username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/credentials/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/credentials/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/credentials/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/credentials/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/credentials/:id"

payload = {
    "_links": [],
    "customerId": "",
    "expiredTime": "",
    "id": "",
    "password": "",
    "username": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/credentials/:id"

payload <- "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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}}/credentials/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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/credentials/:id') do |req|
  req.body = "{\n  \"_links\": [],\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"password\": \"\",\n  \"username\": \"\"\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}}/credentials/:id";

    let payload = json!({
        "_links": (),
        "customerId": "",
        "expiredTime": "",
        "id": "",
        "password": "",
        "username": ""
    });

    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 '{
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
}' |  \
  http PUT {{baseUrl}}/credentials/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [],\n  "customerId": "",\n  "expiredTime": "",\n  "id": "",\n  "password": "",\n  "username": ""\n}' \
  --output-document \
  - {{baseUrl}}/credentials/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "password": "",
  "username": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/credentials/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/password-tokens/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/password-tokens/:id")

require "http/client"

url = "{{baseUrl}}/password-tokens/: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}}/password-tokens/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/password-tokens/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/password-tokens/: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/password-tokens/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/password-tokens/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/password-tokens/: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}}/password-tokens/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/password-tokens/: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}}/password-tokens/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/password-tokens/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/password-tokens/: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}}/password-tokens/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/password-tokens/: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/password-tokens/: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}}/password-tokens/: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}}/password-tokens/: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}}/password-tokens/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/password-tokens/: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}}/password-tokens/: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}}/password-tokens/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/password-tokens/: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}}/password-tokens/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/password-tokens/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/password-tokens/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/password-tokens/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/password-tokens/:id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/password-tokens/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/password-tokens/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/password-tokens/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/password-tokens/: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/password-tokens/: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}}/password-tokens/: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}}/password-tokens/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/password-tokens/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/password-tokens/: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}}/credentials/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/credentials/:id")

require "http/client"

url = "{{baseUrl}}/credentials/: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}}/credentials/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/credentials/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/credentials/: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/credentials/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/credentials/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/credentials/: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}}/credentials/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/credentials/: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}}/credentials/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/credentials/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/credentials/: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}}/credentials/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/credentials/: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/credentials/: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}}/credentials/: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}}/credentials/: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}}/credentials/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/credentials/: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}}/credentials/: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}}/credentials/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/credentials/: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}}/credentials/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/credentials/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/credentials/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/credentials/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/credentials/:id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/credentials/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/credentials/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/credentials/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/credentials/: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/credentials/: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}}/credentials/: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}}/credentials/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/credentials/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/credentials/: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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/authentication-tokens/:token/exchange");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "reb-apikey: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/authentication-tokens/:token/exchange" {:headers {:reb-apikey "{{apiKey}}"}
                                                                                  :content-type :json
                                                                                  :form-params {:_links [{:rel ""}]
                                                                                                :acl [{:permissions ""
                                                                                                       :scope ""}]
                                                                                                :createdTime ""
                                                                                                :customClaims {}
                                                                                                :customerId ""
                                                                                                :expiredTime ""
                                                                                                :id ""
                                                                                                :invalidate false
                                                                                                :oneTimePassword ""
                                                                                                :token ""
                                                                                                :type ""
                                                                                                :updatedTime ""}})

require "http/client"

url = "{{baseUrl}}/authentication-tokens/:token/exchange"
headers = HTTP::Headers{
  "reb-apikey" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\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}}/authentication-tokens/:token/exchange"),
    Headers =
    {
        { "reb-apikey", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\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}}/authentication-tokens/:token/exchange");
var request = new RestRequest("", Method.Post);
request.AddHeader("reb-apikey", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/authentication-tokens/:token/exchange"

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("reb-apikey", "{{apiKey}}")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/authentication-tokens/:token/exchange HTTP/1.1
Reb-Apikey: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 314

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "acl": [
    {
      "permissions": "",
      "scope": ""
    }
  ],
  "createdTime": "",
  "customClaims": {},
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "invalidate": false,
  "oneTimePassword": "",
  "token": "",
  "type": "",
  "updatedTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/authentication-tokens/:token/exchange")
  .setHeader("reb-apikey", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication-tokens/:token/exchange"))
    .header("reb-apikey", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/authentication-tokens/:token/exchange")
  .post(body)
  .addHeader("reb-apikey", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/authentication-tokens/:token/exchange")
  .header("reb-apikey", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  acl: [
    {
      permissions: '',
      scope: ''
    }
  ],
  createdTime: '',
  customClaims: {},
  customerId: '',
  expiredTime: '',
  id: '',
  invalidate: false,
  oneTimePassword: '',
  token: '',
  type: '',
  updatedTime: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/authentication-tokens/:token/exchange');
xhr.setRequestHeader('reb-apikey', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/authentication-tokens/:token/exchange',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    acl: [{permissions: '', scope: ''}],
    createdTime: '',
    customClaims: {},
    customerId: '',
    expiredTime: '',
    id: '',
    invalidate: false,
    oneTimePassword: '',
    token: '',
    type: '',
    updatedTime: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/authentication-tokens/:token/exchange';
const options = {
  method: 'POST',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"acl":[{"permissions":"","scope":""}],"createdTime":"","customClaims":{},"customerId":"","expiredTime":"","id":"","invalidate":false,"oneTimePassword":"","token":"","type":"","updatedTime":""}'
};

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}}/authentication-tokens/:token/exchange',
  method: 'POST',
  headers: {
    'reb-apikey': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "acl": [\n    {\n      "permissions": "",\n      "scope": ""\n    }\n  ],\n  "createdTime": "",\n  "customClaims": {},\n  "customerId": "",\n  "expiredTime": "",\n  "id": "",\n  "invalidate": false,\n  "oneTimePassword": "",\n  "token": "",\n  "type": "",\n  "updatedTime": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/authentication-tokens/:token/exchange")
  .post(body)
  .addHeader("reb-apikey", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authentication-tokens/:token/exchange',
  headers: {
    'reb-apikey': '{{apiKey}}',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  _links: [{rel: ''}],
  acl: [{permissions: '', scope: ''}],
  createdTime: '',
  customClaims: {},
  customerId: '',
  expiredTime: '',
  id: '',
  invalidate: false,
  oneTimePassword: '',
  token: '',
  type: '',
  updatedTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/authentication-tokens/:token/exchange',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  body: {
    _links: [{rel: ''}],
    acl: [{permissions: '', scope: ''}],
    createdTime: '',
    customClaims: {},
    customerId: '',
    expiredTime: '',
    id: '',
    invalidate: false,
    oneTimePassword: '',
    token: '',
    type: '',
    updatedTime: ''
  },
  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}}/authentication-tokens/:token/exchange');

req.headers({
  'reb-apikey': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  acl: [
    {
      permissions: '',
      scope: ''
    }
  ],
  createdTime: '',
  customClaims: {},
  customerId: '',
  expiredTime: '',
  id: '',
  invalidate: false,
  oneTimePassword: '',
  token: '',
  type: '',
  updatedTime: ''
});

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}}/authentication-tokens/:token/exchange',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    acl: [{permissions: '', scope: ''}],
    createdTime: '',
    customClaims: {},
    customerId: '',
    expiredTime: '',
    id: '',
    invalidate: false,
    oneTimePassword: '',
    token: '',
    type: '',
    updatedTime: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/authentication-tokens/:token/exchange';
const options = {
  method: 'POST',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"acl":[{"permissions":"","scope":""}],"createdTime":"","customClaims":{},"customerId":"","expiredTime":"","id":"","invalidate":false,"oneTimePassword":"","token":"","type":"","updatedTime":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"reb-apikey": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"acl": @[ @{ @"permissions": @"", @"scope": @"" } ],
                              @"createdTime": @"",
                              @"customClaims": @{  },
                              @"customerId": @"",
                              @"expiredTime": @"",
                              @"id": @"",
                              @"invalidate": @NO,
                              @"oneTimePassword": @"",
                              @"token": @"",
                              @"type": @"",
                              @"updatedTime": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authentication-tokens/:token/exchange"]
                                                       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}}/authentication-tokens/:token/exchange" in
let headers = Header.add_list (Header.init ()) [
  ("reb-apikey", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/authentication-tokens/:token/exchange",
  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([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'acl' => [
        [
                'permissions' => '',
                'scope' => ''
        ]
    ],
    'createdTime' => '',
    'customClaims' => [
        
    ],
    'customerId' => '',
    'expiredTime' => '',
    'id' => '',
    'invalidate' => null,
    'oneTimePassword' => '',
    'token' => '',
    'type' => '',
    'updatedTime' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "reb-apikey: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/authentication-tokens/:token/exchange', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "acl": [
    {
      "permissions": "",
      "scope": ""
    }
  ],
  "createdTime": "",
  "customClaims": {},
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "invalidate": false,
  "oneTimePassword": "",
  "token": "",
  "type": "",
  "updatedTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'reb-apikey' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/authentication-tokens/:token/exchange');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'reb-apikey' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'acl' => [
    [
        'permissions' => '',
        'scope' => ''
    ]
  ],
  'createdTime' => '',
  'customClaims' => [
    
  ],
  'customerId' => '',
  'expiredTime' => '',
  'id' => '',
  'invalidate' => null,
  'oneTimePassword' => '',
  'token' => '',
  'type' => '',
  'updatedTime' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'acl' => [
    [
        'permissions' => '',
        'scope' => ''
    ]
  ],
  'createdTime' => '',
  'customClaims' => [
    
  ],
  'customerId' => '',
  'expiredTime' => '',
  'id' => '',
  'invalidate' => null,
  'oneTimePassword' => '',
  'token' => '',
  'type' => '',
  'updatedTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/authentication-tokens/:token/exchange');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'reb-apikey' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("reb-apikey", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/authentication-tokens/:token/exchange' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "acl": [
    {
      "permissions": "",
      "scope": ""
    }
  ],
  "createdTime": "",
  "customClaims": {},
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "invalidate": false,
  "oneTimePassword": "",
  "token": "",
  "type": "",
  "updatedTime": ""
}'

$headers=@{}
$headers.Add("reb-apikey", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication-tokens/:token/exchange' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "acl": [
    {
      "permissions": "",
      "scope": ""
    }
  ],
  "createdTime": "",
  "customClaims": {},
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "invalidate": false,
  "oneTimePassword": "",
  "token": "",
  "type": "",
  "updatedTime": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}"

headers = {
    'reb-apikey': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/authentication-tokens/:token/exchange", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/authentication-tokens/:token/exchange"

payload = {
    "_links": [{ "rel": "" }],
    "acl": [
        {
            "permissions": "",
            "scope": ""
        }
    ],
    "createdTime": "",
    "customClaims": {},
    "customerId": "",
    "expiredTime": "",
    "id": "",
    "invalidate": False,
    "oneTimePassword": "",
    "token": "",
    "type": "",
    "updatedTime": ""
}
headers = {
    "reb-apikey": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication-tokens/:token/exchange"

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('reb-apikey' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication-tokens/:token/exchange")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["reb-apikey"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\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/authentication-tokens/:token/exchange') do |req|
  req.headers['reb-apikey'] = '{{apiKey}}'
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"acl\": [\n    {\n      \"permissions\": \"\",\n      \"scope\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"customClaims\": {},\n  \"customerId\": \"\",\n  \"expiredTime\": \"\",\n  \"id\": \"\",\n  \"invalidate\": false,\n  \"oneTimePassword\": \"\",\n  \"token\": \"\",\n  \"type\": \"\",\n  \"updatedTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/authentication-tokens/:token/exchange";

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "acl": (
            json!({
                "permissions": "",
                "scope": ""
            })
        ),
        "createdTime": "",
        "customClaims": json!({}),
        "customerId": "",
        "expiredTime": "",
        "id": "",
        "invalidate": false,
        "oneTimePassword": "",
        "token": "",
        "type": "",
        "updatedTime": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("reb-apikey", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "acl": [
    {
      "permissions": "",
      "scope": ""
    }
  ],
  "createdTime": "",
  "customClaims": {},
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "invalidate": false,
  "oneTimePassword": "",
  "token": "",
  "type": "",
  "updatedTime": ""
}' |  \
  http POST {{baseUrl}}/authentication-tokens/:token/exchange \
  content-type:application/json \
  reb-apikey:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'reb-apikey: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "acl": [\n    {\n      "permissions": "",\n      "scope": ""\n    }\n  ],\n  "createdTime": "",\n  "customClaims": {},\n  "customerId": "",\n  "expiredTime": "",\n  "id": "",\n  "invalidate": false,\n  "oneTimePassword": "",\n  "token": "",\n  "type": "",\n  "updatedTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/authentication-tokens/:token/exchange

import Foundation

let headers = [
  "reb-apikey": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "_links": [["rel": ""]],
  "acl": [
    [
      "permissions": "",
      "scope": ""
    ]
  ],
  "createdTime": "",
  "customClaims": [],
  "customerId": "",
  "expiredTime": "",
  "id": "",
  "invalidate": false,
  "oneTimePassword": "",
  "token": "",
  "type": "",
  "updatedTime": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authentication-tokens/:token/exchange")! 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}}/authentication-tokens");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "reb-apikey: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/authentication-tokens" {:headers {:reb-apikey "{{apiKey}}"}
                                                                  :content-type :json
                                                                  :form-params {:credentialId ""
                                                                                :mode ""
                                                                                :otpRequired false
                                                                                :token ""}})

require "http/client"

url = "{{baseUrl}}/authentication-tokens"
headers = HTTP::Headers{
  "reb-apikey" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\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}}/authentication-tokens"),
    Headers =
    {
        { "reb-apikey", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\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}}/authentication-tokens");
var request = new RestRequest("", Method.Post);
request.AddHeader("reb-apikey", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/authentication-tokens"

	payload := strings.NewReader("{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("reb-apikey", "{{apiKey}}")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/authentication-tokens HTTP/1.1
Reb-Apikey: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "credentialId": "",
  "mode": "",
  "otpRequired": false,
  "token": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/authentication-tokens")
  .setHeader("reb-apikey", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication-tokens"))
    .header("reb-apikey", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\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  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/authentication-tokens")
  .post(body)
  .addHeader("reb-apikey", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/authentication-tokens")
  .header("reb-apikey", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  credentialId: '',
  mode: '',
  otpRequired: false,
  token: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/authentication-tokens');
xhr.setRequestHeader('reb-apikey', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/authentication-tokens',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  data: {credentialId: '', mode: '', otpRequired: false, token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/authentication-tokens';
const options = {
  method: 'POST',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"credentialId":"","mode":"","otpRequired":false,"token":""}'
};

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}}/authentication-tokens',
  method: 'POST',
  headers: {
    'reb-apikey': '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "credentialId": "",\n  "mode": "",\n  "otpRequired": false,\n  "token": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/authentication-tokens")
  .post(body)
  .addHeader("reb-apikey", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authentication-tokens',
  headers: {
    'reb-apikey': '{{apiKey}}',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({credentialId: '', mode: '', otpRequired: false, token: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/authentication-tokens',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  body: {credentialId: '', mode: '', otpRequired: false, token: ''},
  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}}/authentication-tokens');

req.headers({
  'reb-apikey': '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  credentialId: '',
  mode: '',
  otpRequired: false,
  token: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/authentication-tokens',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  data: {credentialId: '', mode: '', otpRequired: false, token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/authentication-tokens';
const options = {
  method: 'POST',
  headers: {'reb-apikey': '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"credentialId":"","mode":"","otpRequired":false,"token":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"reb-apikey": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"credentialId": @"",
                              @"mode": @"",
                              @"otpRequired": @NO,
                              @"token": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authentication-tokens"]
                                                       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}}/authentication-tokens" in
let headers = Header.add_list (Header.init ()) [
  ("reb-apikey", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/authentication-tokens",
  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([
    'credentialId' => '',
    'mode' => '',
    'otpRequired' => null,
    'token' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "reb-apikey: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/authentication-tokens', [
  'body' => '{
  "credentialId": "",
  "mode": "",
  "otpRequired": false,
  "token": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'reb-apikey' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/authentication-tokens');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'reb-apikey' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'credentialId' => '',
  'mode' => '',
  'otpRequired' => null,
  'token' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'credentialId' => '',
  'mode' => '',
  'otpRequired' => null,
  'token' => ''
]));
$request->setRequestUrl('{{baseUrl}}/authentication-tokens');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'reb-apikey' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("reb-apikey", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/authentication-tokens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "credentialId": "",
  "mode": "",
  "otpRequired": false,
  "token": ""
}'

$headers=@{}
$headers.Add("reb-apikey", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication-tokens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "credentialId": "",
  "mode": "",
  "otpRequired": false,
  "token": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}"

headers = {
    'reb-apikey': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/authentication-tokens", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/authentication-tokens"

payload = {
    "credentialId": "",
    "mode": "",
    "otpRequired": False,
    "token": ""
}
headers = {
    "reb-apikey": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication-tokens"

payload <- "{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('reb-apikey' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication-tokens")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["reb-apikey"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\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/authentication-tokens') do |req|
  req.headers['reb-apikey'] = '{{apiKey}}'
  req.body = "{\n  \"credentialId\": \"\",\n  \"mode\": \"\",\n  \"otpRequired\": false,\n  \"token\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/authentication-tokens";

    let payload = json!({
        "credentialId": "",
        "mode": "",
        "otpRequired": false,
        "token": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("reb-apikey", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "credentialId": "",
  "mode": "",
  "otpRequired": false,
  "token": ""
}' |  \
  http POST {{baseUrl}}/authentication-tokens \
  content-type:application/json \
  reb-apikey:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'reb-apikey: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "credentialId": "",\n  "mode": "",\n  "otpRequired": false,\n  "token": ""\n}' \
  --output-document \
  - {{baseUrl}}/authentication-tokens

import Foundation

let headers = [
  "reb-apikey": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "credentialId": "",
  "mode": "",
  "otpRequired": false,
  "token": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authentication-tokens")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/authentication-tokens/:token");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "reb-apikey: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/authentication-tokens/:token" {:headers {:reb-apikey "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/authentication-tokens/:token"
headers = HTTP::Headers{
  "reb-apikey" => "{{apiKey}}"
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/authentication-tokens/:token"),
    Headers =
    {
        { "reb-apikey", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/authentication-tokens/:token");
var request = new RestRequest("", Method.Delete);
request.AddHeader("reb-apikey", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/authentication-tokens/:token"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("reb-apikey", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/authentication-tokens/:token HTTP/1.1
Reb-Apikey: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/authentication-tokens/:token")
  .setHeader("reb-apikey", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication-tokens/:token"))
    .header("reb-apikey", "{{apiKey}}")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/authentication-tokens/:token")
  .delete(null)
  .addHeader("reb-apikey", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/authentication-tokens/:token")
  .header("reb-apikey", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/authentication-tokens/:token');
xhr.setRequestHeader('reb-apikey', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/authentication-tokens/:token',
  headers: {'reb-apikey': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/authentication-tokens/:token';
const options = {method: 'DELETE', headers: {'reb-apikey': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/authentication-tokens/:token',
  method: 'DELETE',
  headers: {
    'reb-apikey': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/authentication-tokens/:token")
  .delete(null)
  .addHeader("reb-apikey", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authentication-tokens/:token',
  headers: {
    'reb-apikey': '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/authentication-tokens/:token',
  headers: {'reb-apikey': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/authentication-tokens/:token');

req.headers({
  'reb-apikey': '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/authentication-tokens/:token',
  headers: {'reb-apikey': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/authentication-tokens/:token';
const options = {method: 'DELETE', headers: {'reb-apikey': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"reb-apikey": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authentication-tokens/:token"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/authentication-tokens/:token" in
let headers = Header.add (Header.init ()) "reb-apikey" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/authentication-tokens/:token",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "reb-apikey: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/authentication-tokens/:token', [
  'headers' => [
    'reb-apikey' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/authentication-tokens/:token');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'reb-apikey' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/authentication-tokens/:token');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'reb-apikey' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("reb-apikey", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/authentication-tokens/:token' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("reb-apikey", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication-tokens/:token' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'reb-apikey': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/authentication-tokens/:token", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/authentication-tokens/:token"

headers = {"reb-apikey": "{{apiKey}}"}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication-tokens/:token"

response <- VERB("DELETE", url, add_headers('reb-apikey' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication-tokens/:token")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["reb-apikey"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/authentication-tokens/:token') do |req|
  req.headers['reb-apikey'] = '{{apiKey}}'
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/authentication-tokens/:token";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("reb-apikey", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/authentication-tokens/:token \
  reb-apikey:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'reb-apikey: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/authentication-tokens/:token

import Foundation

let headers = ["reb-apikey": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authentication-tokens/:token")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/authentication-options");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/authentication-options")

require "http/client"

url = "{{baseUrl}}/authentication-options"

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}}/authentication-options"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/authentication-options");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/authentication-options"

	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/authentication-options HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/authentication-options")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication-options"))
    .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}}/authentication-options")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/authentication-options")
  .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}}/authentication-options');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/authentication-options'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/authentication-options';
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}}/authentication-options',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/authentication-options")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authentication-options',
  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}}/authentication-options'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/authentication-options');

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}}/authentication-options'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/authentication-options';
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}}/authentication-options"]
                                                       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}}/authentication-options" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/authentication-options",
  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}}/authentication-options');

echo $response->getBody();

setUrl('{{baseUrl}}/authentication-options');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/authentication-options');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/authentication-options' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication-options' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/authentication-options")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/authentication-options"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication-options"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication-options")

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/authentication-options') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/authentication-options";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/authentication-options

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/authentication-options

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authentication-options")! 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}}/password-tokens/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/password-tokens/:id")

require "http/client"

url = "{{baseUrl}}/password-tokens/: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}}/password-tokens/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/password-tokens/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/password-tokens/: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/password-tokens/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/password-tokens/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/password-tokens/: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}}/password-tokens/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/password-tokens/: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}}/password-tokens/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/password-tokens/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/password-tokens/: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}}/password-tokens/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/password-tokens/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/password-tokens/: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}}/password-tokens/: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}}/password-tokens/: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}}/password-tokens/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/password-tokens/: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}}/password-tokens/: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}}/password-tokens/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/password-tokens/: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}}/password-tokens/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/password-tokens/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/password-tokens/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/password-tokens/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/password-tokens/:id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/password-tokens/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/password-tokens/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/password-tokens/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/password-tokens/: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/password-tokens/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/password-tokens/: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}}/password-tokens/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/password-tokens/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/password-tokens/: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}}/credentials/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/credentials/:id")

require "http/client"

url = "{{baseUrl}}/credentials/: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}}/credentials/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/credentials/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/credentials/: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/credentials/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/credentials/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/credentials/: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}}/credentials/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/credentials/: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}}/credentials/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/credentials/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/credentials/: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}}/credentials/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/credentials/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/credentials/: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}}/credentials/: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}}/credentials/: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}}/credentials/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/credentials/: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}}/credentials/: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}}/credentials/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/credentials/: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}}/credentials/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/credentials/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/credentials/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/credentials/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/credentials/:id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/credentials/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/credentials/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/credentials/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/credentials/: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/credentials/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/credentials/: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}}/credentials/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/credentials/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/credentials/: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}}/authentication-tokens");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/authentication-tokens")

require "http/client"

url = "{{baseUrl}}/authentication-tokens"

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}}/authentication-tokens"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/authentication-tokens");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/authentication-tokens"

	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/authentication-tokens HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/authentication-tokens")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication-tokens"))
    .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}}/authentication-tokens")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/authentication-tokens")
  .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}}/authentication-tokens');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/authentication-tokens'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/authentication-tokens';
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}}/authentication-tokens',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/authentication-tokens")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authentication-tokens',
  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}}/authentication-tokens'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/authentication-tokens');

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}}/authentication-tokens'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/authentication-tokens';
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}}/authentication-tokens"]
                                                       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}}/authentication-tokens" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/authentication-tokens",
  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}}/authentication-tokens');

echo $response->getBody();

setUrl('{{baseUrl}}/authentication-tokens');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/authentication-tokens');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/authentication-tokens' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication-tokens' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/authentication-tokens")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/authentication-tokens"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication-tokens"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication-tokens")

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/authentication-tokens') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/authentication-tokens";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/authentication-tokens

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/authentication-tokens

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authentication-tokens")! 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}}/credentials");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/credentials")

require "http/client"

url = "{{baseUrl}}/credentials"

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}}/credentials"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/credentials");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/credentials"

	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/credentials HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/credentials")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/credentials"))
    .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}}/credentials")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/credentials")
  .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}}/credentials');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/credentials'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/credentials';
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}}/credentials',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/credentials")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/credentials',
  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}}/credentials'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/credentials');

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}}/credentials'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/credentials';
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}}/credentials"]
                                                       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}}/credentials" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/credentials",
  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}}/credentials');

echo $response->getBody();

setUrl('{{baseUrl}}/credentials');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/credentials');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/credentials' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/credentials' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/credentials")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/credentials"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/credentials"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/credentials")

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/credentials') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/credentials";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/credentials

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/credentials

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/credentials")! 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}}/password-tokens");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/password-tokens")

require "http/client"

url = "{{baseUrl}}/password-tokens"

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}}/password-tokens"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/password-tokens");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/password-tokens"

	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/password-tokens HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/password-tokens")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/password-tokens"))
    .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}}/password-tokens")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/password-tokens")
  .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}}/password-tokens');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/password-tokens'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/password-tokens';
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}}/password-tokens',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/password-tokens")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/password-tokens',
  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}}/password-tokens'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/password-tokens');

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}}/password-tokens'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/password-tokens';
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}}/password-tokens"]
                                                       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}}/password-tokens" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/password-tokens",
  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}}/password-tokens');

echo $response->getBody();

setUrl('{{baseUrl}}/password-tokens');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/password-tokens');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/password-tokens' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/password-tokens' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/password-tokens")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/password-tokens"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/password-tokens"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/password-tokens")

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/password-tokens') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/password-tokens";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/password-tokens

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/password-tokens

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/password-tokens")! 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}}/authentication-tokens/:token");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "reb-apikey: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/authentication-tokens/:token" {:headers {:reb-apikey "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/authentication-tokens/:token"
headers = HTTP::Headers{
  "reb-apikey" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/authentication-tokens/:token"),
    Headers =
    {
        { "reb-apikey", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/authentication-tokens/:token");
var request = new RestRequest("", Method.Get);
request.AddHeader("reb-apikey", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/authentication-tokens/:token"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("reb-apikey", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/authentication-tokens/:token HTTP/1.1
Reb-Apikey: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/authentication-tokens/:token")
  .setHeader("reb-apikey", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication-tokens/:token"))
    .header("reb-apikey", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/authentication-tokens/:token")
  .get()
  .addHeader("reb-apikey", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/authentication-tokens/:token")
  .header("reb-apikey", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/authentication-tokens/:token');
xhr.setRequestHeader('reb-apikey', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/authentication-tokens/:token',
  headers: {'reb-apikey': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/authentication-tokens/:token';
const options = {method: 'GET', headers: {'reb-apikey': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/authentication-tokens/:token',
  method: 'GET',
  headers: {
    'reb-apikey': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/authentication-tokens/:token")
  .get()
  .addHeader("reb-apikey", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authentication-tokens/:token',
  headers: {
    'reb-apikey': '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/authentication-tokens/:token',
  headers: {'reb-apikey': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/authentication-tokens/:token');

req.headers({
  'reb-apikey': '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/authentication-tokens/:token',
  headers: {'reb-apikey': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/authentication-tokens/:token';
const options = {method: 'GET', headers: {'reb-apikey': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"reb-apikey": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authentication-tokens/:token"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/authentication-tokens/:token" in
let headers = Header.add (Header.init ()) "reb-apikey" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/authentication-tokens/:token",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "reb-apikey: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/authentication-tokens/:token', [
  'headers' => [
    'reb-apikey' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/authentication-tokens/:token');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'reb-apikey' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/authentication-tokens/:token');
$request->setRequestMethod('GET');
$request->setHeaders([
  'reb-apikey' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("reb-apikey", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/authentication-tokens/:token' -Method GET -Headers $headers

$headers=@{}
$headers.Add("reb-apikey", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication-tokens/:token' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'reb-apikey': "{{apiKey}}" }

conn.request("GET", "/baseUrl/authentication-tokens/:token", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/authentication-tokens/:token"

headers = {"reb-apikey": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication-tokens/:token"

response <- VERB("GET", url, add_headers('reb-apikey' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication-tokens/:token")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["reb-apikey"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/authentication-tokens/:token') do |req|
  req.headers['reb-apikey'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/authentication-tokens/:token";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("reb-apikey", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/authentication-tokens/:token \
  reb-apikey:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'reb-apikey: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/authentication-tokens/:token

import Foundation

let headers = ["reb-apikey": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authentication-tokens/:token")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customer-timeline-custom-events");

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/customer-timeline-custom-events" {:content-type :json
                                                                            :form-params {:_links [{:rel ""}]
                                                                                          :createdTime ""
                                                                                          :id ""
                                                                                          :name ""
                                                                                          :updatedTime ""}})

require "http/client"

url = "{{baseUrl}}/customer-timeline-custom-events"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\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}}/customer-timeline-custom-events"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\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}}/customer-timeline-custom-events");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customer-timeline-custom-events"

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\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/customer-timeline-custom-events HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 117

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "id": "",
  "name": "",
  "updatedTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/customer-timeline-custom-events")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customer-timeline-custom-events"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/customer-timeline-custom-events")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/customer-timeline-custom-events")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  id: '',
  name: '',
  updatedTime: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/customer-timeline-custom-events');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customer-timeline-custom-events',
  headers: {'content-type': 'application/json'},
  data: {_links: [{rel: ''}], createdTime: '', id: '', name: '', updatedTime: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customer-timeline-custom-events';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","id":"","name":"","updatedTime":""}'
};

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}}/customer-timeline-custom-events',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "id": "",\n  "name": "",\n  "updatedTime": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/customer-timeline-custom-events")
  .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/customer-timeline-custom-events',
  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({_links: [{rel: ''}], createdTime: '', id: '', name: '', updatedTime: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customer-timeline-custom-events',
  headers: {'content-type': 'application/json'},
  body: {_links: [{rel: ''}], createdTime: '', id: '', name: '', updatedTime: ''},
  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}}/customer-timeline-custom-events');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  createdTime: '',
  id: '',
  name: '',
  updatedTime: ''
});

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}}/customer-timeline-custom-events',
  headers: {'content-type': 'application/json'},
  data: {_links: [{rel: ''}], createdTime: '', id: '', name: '', updatedTime: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customer-timeline-custom-events';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"createdTime":"","id":"","name":"","updatedTime":""}'
};

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 = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"createdTime": @"",
                              @"id": @"",
                              @"name": @"",
                              @"updatedTime": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customer-timeline-custom-events"]
                                                       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}}/customer-timeline-custom-events" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customer-timeline-custom-events",
  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([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'createdTime' => '',
    'id' => '',
    'name' => '',
    'updatedTime' => ''
  ]),
  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}}/customer-timeline-custom-events', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "id": "",
  "name": "",
  "updatedTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/customer-timeline-custom-events');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'id' => '',
  'name' => '',
  'updatedTime' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'createdTime' => '',
  'id' => '',
  'name' => '',
  'updatedTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/customer-timeline-custom-events');
$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}}/customer-timeline-custom-events' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "id": "",
  "name": "",
  "updatedTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/customer-timeline-custom-events' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "id": "",
  "name": "",
  "updatedTime": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/customer-timeline-custom-events", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customer-timeline-custom-events"

payload = {
    "_links": [{ "rel": "" }],
    "createdTime": "",
    "id": "",
    "name": "",
    "updatedTime": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customer-timeline-custom-events"

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\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}}/customer-timeline-custom-events")

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\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/customer-timeline-custom-events') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"createdTime\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"updatedTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customer-timeline-custom-events";

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "createdTime": "",
        "id": "",
        "name": "",
        "updatedTime": ""
    });

    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 '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "createdTime": "",
  "id": "",
  "name": "",
  "updatedTime": ""
}' |  \
  http POST {{baseUrl}}/customer-timeline-custom-events \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "createdTime": "",\n  "id": "",\n  "name": "",\n  "updatedTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/customer-timeline-custom-events

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "createdTime": "",
  "id": "",
  "name": "",
  "updatedTime": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customer-timeline-custom-events")! 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}}/customers/:id/lead-source");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/customers/:id/lead-source")

require "http/client"

url = "{{baseUrl}}/customers/:id/lead-source"

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}}/customers/:id/lead-source"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:id/lead-source");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:id/lead-source"

	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/customers/:id/lead-source HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/customers/:id/lead-source")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:id/lead-source"))
    .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}}/customers/:id/lead-source")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/customers/:id/lead-source")
  .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}}/customers/:id/lead-source');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/customers/:id/lead-source'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:id/lead-source';
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}}/customers/:id/lead-source',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:id/lead-source")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:id/lead-source',
  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}}/customers/:id/lead-source'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/customers/:id/lead-source');

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}}/customers/:id/lead-source'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:id/lead-source';
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}}/customers/:id/lead-source"]
                                                       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}}/customers/:id/lead-source" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:id/lead-source",
  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}}/customers/:id/lead-source');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:id/lead-source');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:id/lead-source');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:id/lead-source' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:id/lead-source' -Method PUT 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/customers/:id/lead-source")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:id/lead-source"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:id/lead-source"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:id/lead-source")

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/customers/:id/lead-source') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:id/lead-source";

    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}}/customers/:id/lead-source

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/customers/:id/lead-source

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:id/lead-source")! 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}}/customers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/customers" {:content-type :json
                                                      :form-params {:_embedded []
                                                                    :_links []
                                                                    :averageValue {:amount ""
                                                                                   :amountUsd ""
                                                                                   :currency ""}
                                                                    :createdTime ""
                                                                    :customFields {}
                                                                    :defaultPaymentInstrument {}
                                                                    :email ""
                                                                    :firstName ""
                                                                    :id ""
                                                                    :invoiceCount 0
                                                                    :lastName ""
                                                                    :lastPaymentTime ""
                                                                    :lifetimeRevenue {:amount ""
                                                                                      :amountUsd ""
                                                                                      :currency ""}
                                                                    :paymentCount 0
                                                                    :paymentToken ""
                                                                    :primaryAddress {:address ""
                                                                                     :address2 ""
                                                                                     :city ""
                                                                                     :country ""
                                                                                     :emails [{:label ""
                                                                                               :primary false
                                                                                               :value ""}]
                                                                                     :firstName ""
                                                                                     :hash ""
                                                                                     :lastName ""
                                                                                     :organization ""
                                                                                     :phoneNumbers [{:label ""
                                                                                                     :primary false
                                                                                                     :value ""}]
                                                                                     :postalCode ""
                                                                                     :region ""}
                                                                    :revision 0
                                                                    :tags [{:_links []
                                                                            :createdTime ""
                                                                            :id ""
                                                                            :name ""
                                                                            :updatedTime ""}]
                                                                    :updatedTime ""
                                                                    :websiteId ""}})

require "http/client"

url = "{{baseUrl}}/customers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/customers"),
    Content = new StringContent("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers"

	payload := strings.NewReader("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/customers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1064

{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/customers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\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  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/customers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/customers")
  .header("content-type", "application/json")
  .body("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _embedded: [],
  _links: [],
  averageValue: {
    amount: '',
    amountUsd: '',
    currency: ''
  },
  createdTime: '',
  customFields: {},
  defaultPaymentInstrument: {},
  email: '',
  firstName: '',
  id: '',
  invoiceCount: 0,
  lastName: '',
  lastPaymentTime: '',
  lifetimeRevenue: {
    amount: '',
    amountUsd: '',
    currency: ''
  },
  paymentCount: 0,
  paymentToken: '',
  primaryAddress: {
    address: '',
    address2: '',
    city: '',
    country: '',
    emails: [
      {
        label: '',
        primary: false,
        value: ''
      }
    ],
    firstName: '',
    hash: '',
    lastName: '',
    organization: '',
    phoneNumbers: [
      {
        label: '',
        primary: false,
        value: ''
      }
    ],
    postalCode: '',
    region: ''
  },
  revision: 0,
  tags: [
    {
      _links: [],
      createdTime: '',
      id: '',
      name: '',
      updatedTime: ''
    }
  ],
  updatedTime: '',
  websiteId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/customers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers',
  headers: {'content-type': 'application/json'},
  data: {
    _embedded: [],
    _links: [],
    averageValue: {amount: '', amountUsd: '', currency: ''},
    createdTime: '',
    customFields: {},
    defaultPaymentInstrument: {},
    email: '',
    firstName: '',
    id: '',
    invoiceCount: 0,
    lastName: '',
    lastPaymentTime: '',
    lifetimeRevenue: {amount: '', amountUsd: '', currency: ''},
    paymentCount: 0,
    paymentToken: '',
    primaryAddress: {
      address: '',
      address2: '',
      city: '',
      country: '',
      emails: [{label: '', primary: false, value: ''}],
      firstName: '',
      hash: '',
      lastName: '',
      organization: '',
      phoneNumbers: [{label: '', primary: false, value: ''}],
      postalCode: '',
      region: ''
    },
    revision: 0,
    tags: [{_links: [], createdTime: '', id: '', name: '', updatedTime: ''}],
    updatedTime: '',
    websiteId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_embedded":[],"_links":[],"averageValue":{"amount":"","amountUsd":"","currency":""},"createdTime":"","customFields":{},"defaultPaymentInstrument":{},"email":"","firstName":"","id":"","invoiceCount":0,"lastName":"","lastPaymentTime":"","lifetimeRevenue":{"amount":"","amountUsd":"","currency":""},"paymentCount":0,"paymentToken":"","primaryAddress":{"address":"","address2":"","city":"","country":"","emails":[{"label":"","primary":false,"value":""}],"firstName":"","hash":"","lastName":"","organization":"","phoneNumbers":[{"label":"","primary":false,"value":""}],"postalCode":"","region":""},"revision":0,"tags":[{"_links":[],"createdTime":"","id":"","name":"","updatedTime":""}],"updatedTime":"","websiteId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_embedded": [],\n  "_links": [],\n  "averageValue": {\n    "amount": "",\n    "amountUsd": "",\n    "currency": ""\n  },\n  "createdTime": "",\n  "customFields": {},\n  "defaultPaymentInstrument": {},\n  "email": "",\n  "firstName": "",\n  "id": "",\n  "invoiceCount": 0,\n  "lastName": "",\n  "lastPaymentTime": "",\n  "lifetimeRevenue": {\n    "amount": "",\n    "amountUsd": "",\n    "currency": ""\n  },\n  "paymentCount": 0,\n  "paymentToken": "",\n  "primaryAddress": {\n    "address": "",\n    "address2": "",\n    "city": "",\n    "country": "",\n    "emails": [\n      {\n        "label": "",\n        "primary": false,\n        "value": ""\n      }\n    ],\n    "firstName": "",\n    "hash": "",\n    "lastName": "",\n    "organization": "",\n    "phoneNumbers": [\n      {\n        "label": "",\n        "primary": false,\n        "value": ""\n      }\n    ],\n    "postalCode": "",\n    "region": ""\n  },\n  "revision": 0,\n  "tags": [\n    {\n      "_links": [],\n      "createdTime": "",\n      "id": "",\n      "name": "",\n      "updatedTime": ""\n    }\n  ],\n  "updatedTime": "",\n  "websiteId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/customers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  _embedded: [],
  _links: [],
  averageValue: {amount: '', amountUsd: '', currency: ''},
  createdTime: '',
  customFields: {},
  defaultPaymentInstrument: {},
  email: '',
  firstName: '',
  id: '',
  invoiceCount: 0,
  lastName: '',
  lastPaymentTime: '',
  lifetimeRevenue: {amount: '', amountUsd: '', currency: ''},
  paymentCount: 0,
  paymentToken: '',
  primaryAddress: {
    address: '',
    address2: '',
    city: '',
    country: '',
    emails: [{label: '', primary: false, value: ''}],
    firstName: '',
    hash: '',
    lastName: '',
    organization: '',
    phoneNumbers: [{label: '', primary: false, value: ''}],
    postalCode: '',
    region: ''
  },
  revision: 0,
  tags: [{_links: [], createdTime: '', id: '', name: '', updatedTime: ''}],
  updatedTime: '',
  websiteId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers',
  headers: {'content-type': 'application/json'},
  body: {
    _embedded: [],
    _links: [],
    averageValue: {amount: '', amountUsd: '', currency: ''},
    createdTime: '',
    customFields: {},
    defaultPaymentInstrument: {},
    email: '',
    firstName: '',
    id: '',
    invoiceCount: 0,
    lastName: '',
    lastPaymentTime: '',
    lifetimeRevenue: {amount: '', amountUsd: '', currency: ''},
    paymentCount: 0,
    paymentToken: '',
    primaryAddress: {
      address: '',
      address2: '',
      city: '',
      country: '',
      emails: [{label: '', primary: false, value: ''}],
      firstName: '',
      hash: '',
      lastName: '',
      organization: '',
      phoneNumbers: [{label: '', primary: false, value: ''}],
      postalCode: '',
      region: ''
    },
    revision: 0,
    tags: [{_links: [], createdTime: '', id: '', name: '', updatedTime: ''}],
    updatedTime: '',
    websiteId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/customers');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _embedded: [],
  _links: [],
  averageValue: {
    amount: '',
    amountUsd: '',
    currency: ''
  },
  createdTime: '',
  customFields: {},
  defaultPaymentInstrument: {},
  email: '',
  firstName: '',
  id: '',
  invoiceCount: 0,
  lastName: '',
  lastPaymentTime: '',
  lifetimeRevenue: {
    amount: '',
    amountUsd: '',
    currency: ''
  },
  paymentCount: 0,
  paymentToken: '',
  primaryAddress: {
    address: '',
    address2: '',
    city: '',
    country: '',
    emails: [
      {
        label: '',
        primary: false,
        value: ''
      }
    ],
    firstName: '',
    hash: '',
    lastName: '',
    organization: '',
    phoneNumbers: [
      {
        label: '',
        primary: false,
        value: ''
      }
    ],
    postalCode: '',
    region: ''
  },
  revision: 0,
  tags: [
    {
      _links: [],
      createdTime: '',
      id: '',
      name: '',
      updatedTime: ''
    }
  ],
  updatedTime: '',
  websiteId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers',
  headers: {'content-type': 'application/json'},
  data: {
    _embedded: [],
    _links: [],
    averageValue: {amount: '', amountUsd: '', currency: ''},
    createdTime: '',
    customFields: {},
    defaultPaymentInstrument: {},
    email: '',
    firstName: '',
    id: '',
    invoiceCount: 0,
    lastName: '',
    lastPaymentTime: '',
    lifetimeRevenue: {amount: '', amountUsd: '', currency: ''},
    paymentCount: 0,
    paymentToken: '',
    primaryAddress: {
      address: '',
      address2: '',
      city: '',
      country: '',
      emails: [{label: '', primary: false, value: ''}],
      firstName: '',
      hash: '',
      lastName: '',
      organization: '',
      phoneNumbers: [{label: '', primary: false, value: ''}],
      postalCode: '',
      region: ''
    },
    revision: 0,
    tags: [{_links: [], createdTime: '', id: '', name: '', updatedTime: ''}],
    updatedTime: '',
    websiteId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_embedded":[],"_links":[],"averageValue":{"amount":"","amountUsd":"","currency":""},"createdTime":"","customFields":{},"defaultPaymentInstrument":{},"email":"","firstName":"","id":"","invoiceCount":0,"lastName":"","lastPaymentTime":"","lifetimeRevenue":{"amount":"","amountUsd":"","currency":""},"paymentCount":0,"paymentToken":"","primaryAddress":{"address":"","address2":"","city":"","country":"","emails":[{"label":"","primary":false,"value":""}],"firstName":"","hash":"","lastName":"","organization":"","phoneNumbers":[{"label":"","primary":false,"value":""}],"postalCode":"","region":""},"revision":0,"tags":[{"_links":[],"createdTime":"","id":"","name":"","updatedTime":""}],"updatedTime":"","websiteId":""}'
};

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 = @{ @"_embedded": @[  ],
                              @"_links": @[  ],
                              @"averageValue": @{ @"amount": @"", @"amountUsd": @"", @"currency": @"" },
                              @"createdTime": @"",
                              @"customFields": @{  },
                              @"defaultPaymentInstrument": @{  },
                              @"email": @"",
                              @"firstName": @"",
                              @"id": @"",
                              @"invoiceCount": @0,
                              @"lastName": @"",
                              @"lastPaymentTime": @"",
                              @"lifetimeRevenue": @{ @"amount": @"", @"amountUsd": @"", @"currency": @"" },
                              @"paymentCount": @0,
                              @"paymentToken": @"",
                              @"primaryAddress": @{ @"address": @"", @"address2": @"", @"city": @"", @"country": @"", @"emails": @[ @{ @"label": @"", @"primary": @NO, @"value": @"" } ], @"firstName": @"", @"hash": @"", @"lastName": @"", @"organization": @"", @"phoneNumbers": @[ @{ @"label": @"", @"primary": @NO, @"value": @"" } ], @"postalCode": @"", @"region": @"" },
                              @"revision": @0,
                              @"tags": @[ @{ @"_links": @[  ], @"createdTime": @"", @"id": @"", @"name": @"", @"updatedTime": @"" } ],
                              @"updatedTime": @"",
                              @"websiteId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    '_embedded' => [
        
    ],
    '_links' => [
        
    ],
    'averageValue' => [
        'amount' => '',
        'amountUsd' => '',
        'currency' => ''
    ],
    'createdTime' => '',
    'customFields' => [
        
    ],
    'defaultPaymentInstrument' => [
        
    ],
    'email' => '',
    'firstName' => '',
    'id' => '',
    'invoiceCount' => 0,
    'lastName' => '',
    'lastPaymentTime' => '',
    'lifetimeRevenue' => [
        'amount' => '',
        'amountUsd' => '',
        'currency' => ''
    ],
    'paymentCount' => 0,
    'paymentToken' => '',
    'primaryAddress' => [
        'address' => '',
        'address2' => '',
        'city' => '',
        'country' => '',
        'emails' => [
                [
                                'label' => '',
                                'primary' => null,
                                'value' => ''
                ]
        ],
        'firstName' => '',
        'hash' => '',
        'lastName' => '',
        'organization' => '',
        'phoneNumbers' => [
                [
                                'label' => '',
                                'primary' => null,
                                'value' => ''
                ]
        ],
        'postalCode' => '',
        'region' => ''
    ],
    'revision' => 0,
    'tags' => [
        [
                '_links' => [
                                
                ],
                'createdTime' => '',
                'id' => '',
                'name' => '',
                'updatedTime' => ''
        ]
    ],
    'updatedTime' => '',
    'websiteId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/customers', [
  'body' => '{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/customers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_embedded' => [
    
  ],
  '_links' => [
    
  ],
  'averageValue' => [
    'amount' => '',
    'amountUsd' => '',
    'currency' => ''
  ],
  'createdTime' => '',
  'customFields' => [
    
  ],
  'defaultPaymentInstrument' => [
    
  ],
  'email' => '',
  'firstName' => '',
  'id' => '',
  'invoiceCount' => 0,
  'lastName' => '',
  'lastPaymentTime' => '',
  'lifetimeRevenue' => [
    'amount' => '',
    'amountUsd' => '',
    'currency' => ''
  ],
  'paymentCount' => 0,
  'paymentToken' => '',
  'primaryAddress' => [
    'address' => '',
    'address2' => '',
    'city' => '',
    'country' => '',
    'emails' => [
        [
                'label' => '',
                'primary' => null,
                'value' => ''
        ]
    ],
    'firstName' => '',
    'hash' => '',
    'lastName' => '',
    'organization' => '',
    'phoneNumbers' => [
        [
                'label' => '',
                'primary' => null,
                'value' => ''
        ]
    ],
    'postalCode' => '',
    'region' => ''
  ],
  'revision' => 0,
  'tags' => [
    [
        '_links' => [
                
        ],
        'createdTime' => '',
        'id' => '',
        'name' => '',
        'updatedTime' => ''
    ]
  ],
  'updatedTime' => '',
  'websiteId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_embedded' => [
    
  ],
  '_links' => [
    
  ],
  'averageValue' => [
    'amount' => '',
    'amountUsd' => '',
    'currency' => ''
  ],
  'createdTime' => '',
  'customFields' => [
    
  ],
  'defaultPaymentInstrument' => [
    
  ],
  'email' => '',
  'firstName' => '',
  'id' => '',
  'invoiceCount' => 0,
  'lastName' => '',
  'lastPaymentTime' => '',
  'lifetimeRevenue' => [
    'amount' => '',
    'amountUsd' => '',
    'currency' => ''
  ],
  'paymentCount' => 0,
  'paymentToken' => '',
  'primaryAddress' => [
    'address' => '',
    'address2' => '',
    'city' => '',
    'country' => '',
    'emails' => [
        [
                'label' => '',
                'primary' => null,
                'value' => ''
        ]
    ],
    'firstName' => '',
    'hash' => '',
    'lastName' => '',
    'organization' => '',
    'phoneNumbers' => [
        [
                'label' => '',
                'primary' => null,
                'value' => ''
        ]
    ],
    'postalCode' => '',
    'region' => ''
  ],
  'revision' => 0,
  'tags' => [
    [
        '_links' => [
                
        ],
        'createdTime' => '',
        'id' => '',
        'name' => '',
        'updatedTime' => ''
    ]
  ],
  'updatedTime' => '',
  'websiteId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/customers');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/customers", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers"

payload = {
    "_embedded": [],
    "_links": [],
    "averageValue": {
        "amount": "",
        "amountUsd": "",
        "currency": ""
    },
    "createdTime": "",
    "customFields": {},
    "defaultPaymentInstrument": {},
    "email": "",
    "firstName": "",
    "id": "",
    "invoiceCount": 0,
    "lastName": "",
    "lastPaymentTime": "",
    "lifetimeRevenue": {
        "amount": "",
        "amountUsd": "",
        "currency": ""
    },
    "paymentCount": 0,
    "paymentToken": "",
    "primaryAddress": {
        "address": "",
        "address2": "",
        "city": "",
        "country": "",
        "emails": [
            {
                "label": "",
                "primary": False,
                "value": ""
            }
        ],
        "firstName": "",
        "hash": "",
        "lastName": "",
        "organization": "",
        "phoneNumbers": [
            {
                "label": "",
                "primary": False,
                "value": ""
            }
        ],
        "postalCode": "",
        "region": ""
    },
    "revision": 0,
    "tags": [
        {
            "_links": [],
            "createdTime": "",
            "id": "",
            "name": "",
            "updatedTime": ""
        }
    ],
    "updatedTime": "",
    "websiteId": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers"

payload <- "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/customers') do |req|
  req.body = "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers";

    let payload = json!({
        "_embedded": (),
        "_links": (),
        "averageValue": json!({
            "amount": "",
            "amountUsd": "",
            "currency": ""
        }),
        "createdTime": "",
        "customFields": json!({}),
        "defaultPaymentInstrument": json!({}),
        "email": "",
        "firstName": "",
        "id": "",
        "invoiceCount": 0,
        "lastName": "",
        "lastPaymentTime": "",
        "lifetimeRevenue": json!({
            "amount": "",
            "amountUsd": "",
            "currency": ""
        }),
        "paymentCount": 0,
        "paymentToken": "",
        "primaryAddress": json!({
            "address": "",
            "address2": "",
            "city": "",
            "country": "",
            "emails": (
                json!({
                    "label": "",
                    "primary": false,
                    "value": ""
                })
            ),
            "firstName": "",
            "hash": "",
            "lastName": "",
            "organization": "",
            "phoneNumbers": (
                json!({
                    "label": "",
                    "primary": false,
                    "value": ""
                })
            ),
            "postalCode": "",
            "region": ""
        }),
        "revision": 0,
        "tags": (
            json!({
                "_links": (),
                "createdTime": "",
                "id": "",
                "name": "",
                "updatedTime": ""
            })
        ),
        "updatedTime": "",
        "websiteId": ""
    });

    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 '{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}' |  \
  http POST {{baseUrl}}/customers \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_embedded": [],\n  "_links": [],\n  "averageValue": {\n    "amount": "",\n    "amountUsd": "",\n    "currency": ""\n  },\n  "createdTime": "",\n  "customFields": {},\n  "defaultPaymentInstrument": {},\n  "email": "",\n  "firstName": "",\n  "id": "",\n  "invoiceCount": 0,\n  "lastName": "",\n  "lastPaymentTime": "",\n  "lifetimeRevenue": {\n    "amount": "",\n    "amountUsd": "",\n    "currency": ""\n  },\n  "paymentCount": 0,\n  "paymentToken": "",\n  "primaryAddress": {\n    "address": "",\n    "address2": "",\n    "city": "",\n    "country": "",\n    "emails": [\n      {\n        "label": "",\n        "primary": false,\n        "value": ""\n      }\n    ],\n    "firstName": "",\n    "hash": "",\n    "lastName": "",\n    "organization": "",\n    "phoneNumbers": [\n      {\n        "label": "",\n        "primary": false,\n        "value": ""\n      }\n    ],\n    "postalCode": "",\n    "region": ""\n  },\n  "revision": 0,\n  "tags": [\n    {\n      "_links": [],\n      "createdTime": "",\n      "id": "",\n      "name": "",\n      "updatedTime": ""\n    }\n  ],\n  "updatedTime": "",\n  "websiteId": ""\n}' \
  --output-document \
  - {{baseUrl}}/customers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_embedded": [],
  "_links": [],
  "averageValue": [
    "amount": "",
    "amountUsd": "",
    "currency": ""
  ],
  "createdTime": "",
  "customFields": [],
  "defaultPaymentInstrument": [],
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": [
    "amount": "",
    "amountUsd": "",
    "currency": ""
  ],
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": [
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      [
        "label": "",
        "primary": false,
        "value": ""
      ]
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      [
        "label": "",
        "primary": false,
        "value": ""
      ]
    ],
    "postalCode": "",
    "region": ""
  ],
  "revision": 0,
  "tags": [
    [
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    ]
  ],
  "updatedTime": "",
  "websiteId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/:id/lead-source");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/customers/:id/lead-source")

require "http/client"

url = "{{baseUrl}}/customers/:id/lead-source"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/customers/:id/lead-source"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:id/lead-source");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:id/lead-source"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/customers/:id/lead-source HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/customers/:id/lead-source")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:id/lead-source"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/customers/:id/lead-source")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/customers/:id/lead-source")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/customers/:id/lead-source');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/customers/:id/lead-source'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:id/lead-source';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers/:id/lead-source',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:id/lead-source")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:id/lead-source',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/customers/:id/lead-source'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/customers/:id/lead-source');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/customers/:id/lead-source'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:id/lead-source';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers/:id/lead-source"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers/:id/lead-source" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:id/lead-source",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/customers/:id/lead-source');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:id/lead-source');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:id/lead-source');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:id/lead-source' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:id/lead-source' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/customers/:id/lead-source")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:id/lead-source"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:id/lead-source"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:id/lead-source")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/customers/:id/lead-source') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:id/lead-source";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/customers/:id/lead-source

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/customers/:id/lead-source

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:id/lead-source")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/:id?targetCustomerId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/customers/:id" {:query-params {:targetCustomerId ""}})

require "http/client"

url = "{{baseUrl}}/customers/:id?targetCustomerId="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/customers/:id?targetCustomerId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:id?targetCustomerId=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:id?targetCustomerId="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/customers/:id?targetCustomerId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/customers/:id?targetCustomerId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:id?targetCustomerId="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/customers/:id?targetCustomerId=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/customers/:id?targetCustomerId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/customers/:id?targetCustomerId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/customers/:id',
  params: {targetCustomerId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:id?targetCustomerId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers/:id?targetCustomerId=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:id?targetCustomerId=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:id?targetCustomerId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/customers/:id',
  qs: {targetCustomerId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/customers/:id');

req.query({
  targetCustomerId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/customers/:id',
  params: {targetCustomerId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:id?targetCustomerId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers/:id?targetCustomerId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers/:id?targetCustomerId=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:id?targetCustomerId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/customers/:id?targetCustomerId=');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'targetCustomerId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:id');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'targetCustomerId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:id?targetCustomerId=' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:id?targetCustomerId=' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/customers/:id?targetCustomerId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:id"

querystring = {"targetCustomerId":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:id"

queryString <- list(targetCustomerId = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:id?targetCustomerId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/customers/:id') do |req|
  req.params['targetCustomerId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:id";

    let querystring = [
        ("targetCustomerId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/customers/:id?targetCustomerId='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/customers/:id?targetCustomerId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:id?targetCustomerId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/:id/lead-source");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/customers/:id/lead-source")

require "http/client"

url = "{{baseUrl}}/customers/:id/lead-source"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/customers/:id/lead-source"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:id/lead-source");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:id/lead-source"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/customers/:id/lead-source HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/customers/:id/lead-source")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:id/lead-source"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/customers/:id/lead-source")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/customers/:id/lead-source")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/customers/:id/lead-source');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/customers/:id/lead-source'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:id/lead-source';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers/:id/lead-source',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:id/lead-source")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:id/lead-source',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/customers/:id/lead-source'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/customers/:id/lead-source');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/customers/:id/lead-source'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:id/lead-source';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers/:id/lead-source"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers/:id/lead-source" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:id/lead-source",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/customers/:id/lead-source');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:id/lead-source');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:id/lead-source');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:id/lead-source' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:id/lead-source' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/customers/:id/lead-source")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:id/lead-source"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:id/lead-source"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:id/lead-source")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/customers/:id/lead-source') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:id/lead-source";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/customers/:id/lead-source

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/customers/:id/lead-source

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:id/lead-source")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/customers/:id")

require "http/client"

url = "{{baseUrl}}/customers/: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}}/customers/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/: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/customers/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/customers/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/: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}}/customers/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/customers/: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}}/customers/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/customers/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/: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}}/customers/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/: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}}/customers/: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}}/customers/: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}}/customers/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/: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}}/customers/: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}}/customers/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/: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}}/customers/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/customers/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/: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/customers/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/: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}}/customers/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/customers/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/: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}}/customers");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/customers")

require "http/client"

url = "{{baseUrl}}/customers"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/customers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/customers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/customers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/customers")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/customers")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/customers');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/customers'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/customers'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/customers');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/customers'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/customers');

echo $response->getBody();

setUrl('{{baseUrl}}/customers');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/customers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/customers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/customers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/customers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers")! 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}}/customers/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/customers/:id" {:content-type :json
                                                         :form-params {:_embedded []
                                                                       :_links []
                                                                       :averageValue {:amount ""
                                                                                      :amountUsd ""
                                                                                      :currency ""}
                                                                       :createdTime ""
                                                                       :customFields {}
                                                                       :defaultPaymentInstrument {}
                                                                       :email ""
                                                                       :firstName ""
                                                                       :id ""
                                                                       :invoiceCount 0
                                                                       :lastName ""
                                                                       :lastPaymentTime ""
                                                                       :lifetimeRevenue {:amount ""
                                                                                         :amountUsd ""
                                                                                         :currency ""}
                                                                       :paymentCount 0
                                                                       :paymentToken ""
                                                                       :primaryAddress {:address ""
                                                                                        :address2 ""
                                                                                        :city ""
                                                                                        :country ""
                                                                                        :emails [{:label ""
                                                                                                  :primary false
                                                                                                  :value ""}]
                                                                                        :firstName ""
                                                                                        :hash ""
                                                                                        :lastName ""
                                                                                        :organization ""
                                                                                        :phoneNumbers [{:label ""
                                                                                                        :primary false
                                                                                                        :value ""}]
                                                                                        :postalCode ""
                                                                                        :region ""}
                                                                       :revision 0
                                                                       :tags [{:_links []
                                                                               :createdTime ""
                                                                               :id ""
                                                                               :name ""
                                                                               :updatedTime ""}]
                                                                       :updatedTime ""
                                                                       :websiteId ""}})

require "http/client"

url = "{{baseUrl}}/customers/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\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}}/customers/:id"),
    Content = new StringContent("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:id"

	payload := strings.NewReader("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\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/customers/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1064

{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/customers/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\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  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/customers/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/customers/:id")
  .header("content-type", "application/json")
  .body("{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _embedded: [],
  _links: [],
  averageValue: {
    amount: '',
    amountUsd: '',
    currency: ''
  },
  createdTime: '',
  customFields: {},
  defaultPaymentInstrument: {},
  email: '',
  firstName: '',
  id: '',
  invoiceCount: 0,
  lastName: '',
  lastPaymentTime: '',
  lifetimeRevenue: {
    amount: '',
    amountUsd: '',
    currency: ''
  },
  paymentCount: 0,
  paymentToken: '',
  primaryAddress: {
    address: '',
    address2: '',
    city: '',
    country: '',
    emails: [
      {
        label: '',
        primary: false,
        value: ''
      }
    ],
    firstName: '',
    hash: '',
    lastName: '',
    organization: '',
    phoneNumbers: [
      {
        label: '',
        primary: false,
        value: ''
      }
    ],
    postalCode: '',
    region: ''
  },
  revision: 0,
  tags: [
    {
      _links: [],
      createdTime: '',
      id: '',
      name: '',
      updatedTime: ''
    }
  ],
  updatedTime: '',
  websiteId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/customers/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/customers/:id',
  headers: {'content-type': 'application/json'},
  data: {
    _embedded: [],
    _links: [],
    averageValue: {amount: '', amountUsd: '', currency: ''},
    createdTime: '',
    customFields: {},
    defaultPaymentInstrument: {},
    email: '',
    firstName: '',
    id: '',
    invoiceCount: 0,
    lastName: '',
    lastPaymentTime: '',
    lifetimeRevenue: {amount: '', amountUsd: '', currency: ''},
    paymentCount: 0,
    paymentToken: '',
    primaryAddress: {
      address: '',
      address2: '',
      city: '',
      country: '',
      emails: [{label: '', primary: false, value: ''}],
      firstName: '',
      hash: '',
      lastName: '',
      organization: '',
      phoneNumbers: [{label: '', primary: false, value: ''}],
      postalCode: '',
      region: ''
    },
    revision: 0,
    tags: [{_links: [], createdTime: '', id: '', name: '', updatedTime: ''}],
    updatedTime: '',
    websiteId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_embedded":[],"_links":[],"averageValue":{"amount":"","amountUsd":"","currency":""},"createdTime":"","customFields":{},"defaultPaymentInstrument":{},"email":"","firstName":"","id":"","invoiceCount":0,"lastName":"","lastPaymentTime":"","lifetimeRevenue":{"amount":"","amountUsd":"","currency":""},"paymentCount":0,"paymentToken":"","primaryAddress":{"address":"","address2":"","city":"","country":"","emails":[{"label":"","primary":false,"value":""}],"firstName":"","hash":"","lastName":"","organization":"","phoneNumbers":[{"label":"","primary":false,"value":""}],"postalCode":"","region":""},"revision":0,"tags":[{"_links":[],"createdTime":"","id":"","name":"","updatedTime":""}],"updatedTime":"","websiteId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_embedded": [],\n  "_links": [],\n  "averageValue": {\n    "amount": "",\n    "amountUsd": "",\n    "currency": ""\n  },\n  "createdTime": "",\n  "customFields": {},\n  "defaultPaymentInstrument": {},\n  "email": "",\n  "firstName": "",\n  "id": "",\n  "invoiceCount": 0,\n  "lastName": "",\n  "lastPaymentTime": "",\n  "lifetimeRevenue": {\n    "amount": "",\n    "amountUsd": "",\n    "currency": ""\n  },\n  "paymentCount": 0,\n  "paymentToken": "",\n  "primaryAddress": {\n    "address": "",\n    "address2": "",\n    "city": "",\n    "country": "",\n    "emails": [\n      {\n        "label": "",\n        "primary": false,\n        "value": ""\n      }\n    ],\n    "firstName": "",\n    "hash": "",\n    "lastName": "",\n    "organization": "",\n    "phoneNumbers": [\n      {\n        "label": "",\n        "primary": false,\n        "value": ""\n      }\n    ],\n    "postalCode": "",\n    "region": ""\n  },\n  "revision": 0,\n  "tags": [\n    {\n      "_links": [],\n      "createdTime": "",\n      "id": "",\n      "name": "",\n      "updatedTime": ""\n    }\n  ],\n  "updatedTime": "",\n  "websiteId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/customers/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  _embedded: [],
  _links: [],
  averageValue: {amount: '', amountUsd: '', currency: ''},
  createdTime: '',
  customFields: {},
  defaultPaymentInstrument: {},
  email: '',
  firstName: '',
  id: '',
  invoiceCount: 0,
  lastName: '',
  lastPaymentTime: '',
  lifetimeRevenue: {amount: '', amountUsd: '', currency: ''},
  paymentCount: 0,
  paymentToken: '',
  primaryAddress: {
    address: '',
    address2: '',
    city: '',
    country: '',
    emails: [{label: '', primary: false, value: ''}],
    firstName: '',
    hash: '',
    lastName: '',
    organization: '',
    phoneNumbers: [{label: '', primary: false, value: ''}],
    postalCode: '',
    region: ''
  },
  revision: 0,
  tags: [{_links: [], createdTime: '', id: '', name: '', updatedTime: ''}],
  updatedTime: '',
  websiteId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/customers/:id',
  headers: {'content-type': 'application/json'},
  body: {
    _embedded: [],
    _links: [],
    averageValue: {amount: '', amountUsd: '', currency: ''},
    createdTime: '',
    customFields: {},
    defaultPaymentInstrument: {},
    email: '',
    firstName: '',
    id: '',
    invoiceCount: 0,
    lastName: '',
    lastPaymentTime: '',
    lifetimeRevenue: {amount: '', amountUsd: '', currency: ''},
    paymentCount: 0,
    paymentToken: '',
    primaryAddress: {
      address: '',
      address2: '',
      city: '',
      country: '',
      emails: [{label: '', primary: false, value: ''}],
      firstName: '',
      hash: '',
      lastName: '',
      organization: '',
      phoneNumbers: [{label: '', primary: false, value: ''}],
      postalCode: '',
      region: ''
    },
    revision: 0,
    tags: [{_links: [], createdTime: '', id: '', name: '', updatedTime: ''}],
    updatedTime: '',
    websiteId: ''
  },
  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}}/customers/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _embedded: [],
  _links: [],
  averageValue: {
    amount: '',
    amountUsd: '',
    currency: ''
  },
  createdTime: '',
  customFields: {},
  defaultPaymentInstrument: {},
  email: '',
  firstName: '',
  id: '',
  invoiceCount: 0,
  lastName: '',
  lastPaymentTime: '',
  lifetimeRevenue: {
    amount: '',
    amountUsd: '',
    currency: ''
  },
  paymentCount: 0,
  paymentToken: '',
  primaryAddress: {
    address: '',
    address2: '',
    city: '',
    country: '',
    emails: [
      {
        label: '',
        primary: false,
        value: ''
      }
    ],
    firstName: '',
    hash: '',
    lastName: '',
    organization: '',
    phoneNumbers: [
      {
        label: '',
        primary: false,
        value: ''
      }
    ],
    postalCode: '',
    region: ''
  },
  revision: 0,
  tags: [
    {
      _links: [],
      createdTime: '',
      id: '',
      name: '',
      updatedTime: ''
    }
  ],
  updatedTime: '',
  websiteId: ''
});

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}}/customers/:id',
  headers: {'content-type': 'application/json'},
  data: {
    _embedded: [],
    _links: [],
    averageValue: {amount: '', amountUsd: '', currency: ''},
    createdTime: '',
    customFields: {},
    defaultPaymentInstrument: {},
    email: '',
    firstName: '',
    id: '',
    invoiceCount: 0,
    lastName: '',
    lastPaymentTime: '',
    lifetimeRevenue: {amount: '', amountUsd: '', currency: ''},
    paymentCount: 0,
    paymentToken: '',
    primaryAddress: {
      address: '',
      address2: '',
      city: '',
      country: '',
      emails: [{label: '', primary: false, value: ''}],
      firstName: '',
      hash: '',
      lastName: '',
      organization: '',
      phoneNumbers: [{label: '', primary: false, value: ''}],
      postalCode: '',
      region: ''
    },
    revision: 0,
    tags: [{_links: [], createdTime: '', id: '', name: '', updatedTime: ''}],
    updatedTime: '',
    websiteId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"_embedded":[],"_links":[],"averageValue":{"amount":"","amountUsd":"","currency":""},"createdTime":"","customFields":{},"defaultPaymentInstrument":{},"email":"","firstName":"","id":"","invoiceCount":0,"lastName":"","lastPaymentTime":"","lifetimeRevenue":{"amount":"","amountUsd":"","currency":""},"paymentCount":0,"paymentToken":"","primaryAddress":{"address":"","address2":"","city":"","country":"","emails":[{"label":"","primary":false,"value":""}],"firstName":"","hash":"","lastName":"","organization":"","phoneNumbers":[{"label":"","primary":false,"value":""}],"postalCode":"","region":""},"revision":0,"tags":[{"_links":[],"createdTime":"","id":"","name":"","updatedTime":""}],"updatedTime":"","websiteId":""}'
};

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 = @{ @"_embedded": @[  ],
                              @"_links": @[  ],
                              @"averageValue": @{ @"amount": @"", @"amountUsd": @"", @"currency": @"" },
                              @"createdTime": @"",
                              @"customFields": @{  },
                              @"defaultPaymentInstrument": @{  },
                              @"email": @"",
                              @"firstName": @"",
                              @"id": @"",
                              @"invoiceCount": @0,
                              @"lastName": @"",
                              @"lastPaymentTime": @"",
                              @"lifetimeRevenue": @{ @"amount": @"", @"amountUsd": @"", @"currency": @"" },
                              @"paymentCount": @0,
                              @"paymentToken": @"",
                              @"primaryAddress": @{ @"address": @"", @"address2": @"", @"city": @"", @"country": @"", @"emails": @[ @{ @"label": @"", @"primary": @NO, @"value": @"" } ], @"firstName": @"", @"hash": @"", @"lastName": @"", @"organization": @"", @"phoneNumbers": @[ @{ @"label": @"", @"primary": @NO, @"value": @"" } ], @"postalCode": @"", @"region": @"" },
                              @"revision": @0,
                              @"tags": @[ @{ @"_links": @[  ], @"createdTime": @"", @"id": @"", @"name": @"", @"updatedTime": @"" } ],
                              @"updatedTime": @"",
                              @"websiteId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    '_embedded' => [
        
    ],
    '_links' => [
        
    ],
    'averageValue' => [
        'amount' => '',
        'amountUsd' => '',
        'currency' => ''
    ],
    'createdTime' => '',
    'customFields' => [
        
    ],
    'defaultPaymentInstrument' => [
        
    ],
    'email' => '',
    'firstName' => '',
    'id' => '',
    'invoiceCount' => 0,
    'lastName' => '',
    'lastPaymentTime' => '',
    'lifetimeRevenue' => [
        'amount' => '',
        'amountUsd' => '',
        'currency' => ''
    ],
    'paymentCount' => 0,
    'paymentToken' => '',
    'primaryAddress' => [
        'address' => '',
        'address2' => '',
        'city' => '',
        'country' => '',
        'emails' => [
                [
                                'label' => '',
                                'primary' => null,
                                'value' => ''
                ]
        ],
        'firstName' => '',
        'hash' => '',
        'lastName' => '',
        'organization' => '',
        'phoneNumbers' => [
                [
                                'label' => '',
                                'primary' => null,
                                'value' => ''
                ]
        ],
        'postalCode' => '',
        'region' => ''
    ],
    'revision' => 0,
    'tags' => [
        [
                '_links' => [
                                
                ],
                'createdTime' => '',
                'id' => '',
                'name' => '',
                'updatedTime' => ''
        ]
    ],
    'updatedTime' => '',
    'websiteId' => ''
  ]),
  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}}/customers/:id', [
  'body' => '{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_embedded' => [
    
  ],
  '_links' => [
    
  ],
  'averageValue' => [
    'amount' => '',
    'amountUsd' => '',
    'currency' => ''
  ],
  'createdTime' => '',
  'customFields' => [
    
  ],
  'defaultPaymentInstrument' => [
    
  ],
  'email' => '',
  'firstName' => '',
  'id' => '',
  'invoiceCount' => 0,
  'lastName' => '',
  'lastPaymentTime' => '',
  'lifetimeRevenue' => [
    'amount' => '',
    'amountUsd' => '',
    'currency' => ''
  ],
  'paymentCount' => 0,
  'paymentToken' => '',
  'primaryAddress' => [
    'address' => '',
    'address2' => '',
    'city' => '',
    'country' => '',
    'emails' => [
        [
                'label' => '',
                'primary' => null,
                'value' => ''
        ]
    ],
    'firstName' => '',
    'hash' => '',
    'lastName' => '',
    'organization' => '',
    'phoneNumbers' => [
        [
                'label' => '',
                'primary' => null,
                'value' => ''
        ]
    ],
    'postalCode' => '',
    'region' => ''
  ],
  'revision' => 0,
  'tags' => [
    [
        '_links' => [
                
        ],
        'createdTime' => '',
        'id' => '',
        'name' => '',
        'updatedTime' => ''
    ]
  ],
  'updatedTime' => '',
  'websiteId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_embedded' => [
    
  ],
  '_links' => [
    
  ],
  'averageValue' => [
    'amount' => '',
    'amountUsd' => '',
    'currency' => ''
  ],
  'createdTime' => '',
  'customFields' => [
    
  ],
  'defaultPaymentInstrument' => [
    
  ],
  'email' => '',
  'firstName' => '',
  'id' => '',
  'invoiceCount' => 0,
  'lastName' => '',
  'lastPaymentTime' => '',
  'lifetimeRevenue' => [
    'amount' => '',
    'amountUsd' => '',
    'currency' => ''
  ],
  'paymentCount' => 0,
  'paymentToken' => '',
  'primaryAddress' => [
    'address' => '',
    'address2' => '',
    'city' => '',
    'country' => '',
    'emails' => [
        [
                'label' => '',
                'primary' => null,
                'value' => ''
        ]
    ],
    'firstName' => '',
    'hash' => '',
    'lastName' => '',
    'organization' => '',
    'phoneNumbers' => [
        [
                'label' => '',
                'primary' => null,
                'value' => ''
        ]
    ],
    'postalCode' => '',
    'region' => ''
  ],
  'revision' => 0,
  'tags' => [
    [
        '_links' => [
                
        ],
        'createdTime' => '',
        'id' => '',
        'name' => '',
        'updatedTime' => ''
    ]
  ],
  'updatedTime' => '',
  'websiteId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/customers/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/customers/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:id"

payload = {
    "_embedded": [],
    "_links": [],
    "averageValue": {
        "amount": "",
        "amountUsd": "",
        "currency": ""
    },
    "createdTime": "",
    "customFields": {},
    "defaultPaymentInstrument": {},
    "email": "",
    "firstName": "",
    "id": "",
    "invoiceCount": 0,
    "lastName": "",
    "lastPaymentTime": "",
    "lifetimeRevenue": {
        "amount": "",
        "amountUsd": "",
        "currency": ""
    },
    "paymentCount": 0,
    "paymentToken": "",
    "primaryAddress": {
        "address": "",
        "address2": "",
        "city": "",
        "country": "",
        "emails": [
            {
                "label": "",
                "primary": False,
                "value": ""
            }
        ],
        "firstName": "",
        "hash": "",
        "lastName": "",
        "organization": "",
        "phoneNumbers": [
            {
                "label": "",
                "primary": False,
                "value": ""
            }
        ],
        "postalCode": "",
        "region": ""
    },
    "revision": 0,
    "tags": [
        {
            "_links": [],
            "createdTime": "",
            "id": "",
            "name": "",
            "updatedTime": ""
        }
    ],
    "updatedTime": "",
    "websiteId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:id"

payload <- "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\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}}/customers/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\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/customers/:id') do |req|
  req.body = "{\n  \"_embedded\": [],\n  \"_links\": [],\n  \"averageValue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"createdTime\": \"\",\n  \"customFields\": {},\n  \"defaultPaymentInstrument\": {},\n  \"email\": \"\",\n  \"firstName\": \"\",\n  \"id\": \"\",\n  \"invoiceCount\": 0,\n  \"lastName\": \"\",\n  \"lastPaymentTime\": \"\",\n  \"lifetimeRevenue\": {\n    \"amount\": \"\",\n    \"amountUsd\": \"\",\n    \"currency\": \"\"\n  },\n  \"paymentCount\": 0,\n  \"paymentToken\": \"\",\n  \"primaryAddress\": {\n    \"address\": \"\",\n    \"address2\": \"\",\n    \"city\": \"\",\n    \"country\": \"\",\n    \"emails\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"firstName\": \"\",\n    \"hash\": \"\",\n    \"lastName\": \"\",\n    \"organization\": \"\",\n    \"phoneNumbers\": [\n      {\n        \"label\": \"\",\n        \"primary\": false,\n        \"value\": \"\"\n      }\n    ],\n    \"postalCode\": \"\",\n    \"region\": \"\"\n  },\n  \"revision\": 0,\n  \"tags\": [\n    {\n      \"_links\": [],\n      \"createdTime\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"updatedTime\": \"\"\n    }\n  ],\n  \"updatedTime\": \"\",\n  \"websiteId\": \"\"\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}}/customers/:id";

    let payload = json!({
        "_embedded": (),
        "_links": (),
        "averageValue": json!({
            "amount": "",
            "amountUsd": "",
            "currency": ""
        }),
        "createdTime": "",
        "customFields": json!({}),
        "defaultPaymentInstrument": json!({}),
        "email": "",
        "firstName": "",
        "id": "",
        "invoiceCount": 0,
        "lastName": "",
        "lastPaymentTime": "",
        "lifetimeRevenue": json!({
            "amount": "",
            "amountUsd": "",
            "currency": ""
        }),
        "paymentCount": 0,
        "paymentToken": "",
        "primaryAddress": json!({
            "address": "",
            "address2": "",
            "city": "",
            "country": "",
            "emails": (
                json!({
                    "label": "",
                    "primary": false,
                    "value": ""
                })
            ),
            "firstName": "",
            "hash": "",
            "lastName": "",
            "organization": "",
            "phoneNumbers": (
                json!({
                    "label": "",
                    "primary": false,
                    "value": ""
                })
            ),
            "postalCode": "",
            "region": ""
        }),
        "revision": 0,
        "tags": (
            json!({
                "_links": (),
                "createdTime": "",
                "id": "",
                "name": "",
                "updatedTime": ""
            })
        ),
        "updatedTime": "",
        "websiteId": ""
    });

    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 '{
  "_embedded": [],
  "_links": [],
  "averageValue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "createdTime": "",
  "customFields": {},
  "defaultPaymentInstrument": {},
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": {
    "amount": "",
    "amountUsd": "",
    "currency": ""
  },
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": {
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      {
        "label": "",
        "primary": false,
        "value": ""
      }
    ],
    "postalCode": "",
    "region": ""
  },
  "revision": 0,
  "tags": [
    {
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    }
  ],
  "updatedTime": "",
  "websiteId": ""
}' |  \
  http PUT {{baseUrl}}/customers/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "_embedded": [],\n  "_links": [],\n  "averageValue": {\n    "amount": "",\n    "amountUsd": "",\n    "currency": ""\n  },\n  "createdTime": "",\n  "customFields": {},\n  "defaultPaymentInstrument": {},\n  "email": "",\n  "firstName": "",\n  "id": "",\n  "invoiceCount": 0,\n  "lastName": "",\n  "lastPaymentTime": "",\n  "lifetimeRevenue": {\n    "amount": "",\n    "amountUsd": "",\n    "currency": ""\n  },\n  "paymentCount": 0,\n  "paymentToken": "",\n  "primaryAddress": {\n    "address": "",\n    "address2": "",\n    "city": "",\n    "country": "",\n    "emails": [\n      {\n        "label": "",\n        "primary": false,\n        "value": ""\n      }\n    ],\n    "firstName": "",\n    "hash": "",\n    "lastName": "",\n    "organization": "",\n    "phoneNumbers": [\n      {\n        "label": "",\n        "primary": false,\n        "value": ""\n      }\n    ],\n    "postalCode": "",\n    "region": ""\n  },\n  "revision": 0,\n  "tags": [\n    {\n      "_links": [],\n      "createdTime": "",\n      "id": "",\n      "name": "",\n      "updatedTime": ""\n    }\n  ],\n  "updatedTime": "",\n  "websiteId": ""\n}' \
  --output-document \
  - {{baseUrl}}/customers/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_embedded": [],
  "_links": [],
  "averageValue": [
    "amount": "",
    "amountUsd": "",
    "currency": ""
  ],
  "createdTime": "",
  "customFields": [],
  "defaultPaymentInstrument": [],
  "email": "",
  "firstName": "",
  "id": "",
  "invoiceCount": 0,
  "lastName": "",
  "lastPaymentTime": "",
  "lifetimeRevenue": [
    "amount": "",
    "amountUsd": "",
    "currency": ""
  ],
  "paymentCount": 0,
  "paymentToken": "",
  "primaryAddress": [
    "address": "",
    "address2": "",
    "city": "",
    "country": "",
    "emails": [
      [
        "label": "",
        "primary": false,
        "value": ""
      ]
    ],
    "firstName": "",
    "hash": "",
    "lastName": "",
    "organization": "",
    "phoneNumbers": [
      [
        "label": "",
        "primary": false,
        "value": ""
      ]
    ],
    "postalCode": "",
    "region": ""
  ],
  "revision": 0,
  "tags": [
    [
      "_links": [],
      "createdTime": "",
      "id": "",
      "name": "",
      "updatedTime": ""
    ]
  ],
  "updatedTime": "",
  "websiteId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/:id/timeline");

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/customers/:id/timeline" {:content-type :json
                                                                   :form-params {:_links [{:rel ""}]
                                                                                 :customData {}
                                                                                 :customEventType ""
                                                                                 :extraData {:actions [{:action ""}]
                                                                                             :author {:userFullName ""
                                                                                                      :userId ""}
                                                                                             :links [{:placeholder ""
                                                                                                      :resourceId ""
                                                                                                      :resourceType ""}]
                                                                                             :mentions {}
                                                                                             :tables [{:footer ""
                                                                                                       :title ""
                                                                                                       :type ""}]}
                                                                                 :id ""
                                                                                 :message ""
                                                                                 :occurredTime ""
                                                                                 :triggeredBy ""
                                                                                 :type ""}})

require "http/client"

url = "{{baseUrl}}/customers/:id/timeline"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/customers/:id/timeline"),
    Content = new StringContent("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:id/timeline");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:id/timeline"

	payload := strings.NewReader("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/customers/:id/timeline HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 569

{
  "_links": [
    {
      "rel": ""
    }
  ],
  "customData": {},
  "customEventType": "",
  "extraData": {
    "actions": [
      {
        "action": ""
      }
    ],
    "author": {
      "userFullName": "",
      "userId": ""
    },
    "links": [
      {
        "placeholder": "",
        "resourceId": "",
        "resourceType": ""
      }
    ],
    "mentions": {},
    "tables": [
      {
        "footer": "",
        "title": "",
        "type": ""
      }
    ]
  },
  "id": "",
  "message": "",
  "occurredTime": "",
  "triggeredBy": "",
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/customers/:id/timeline")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:id/timeline"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/customers/:id/timeline")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/customers/:id/timeline")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: [
    {
      rel: ''
    }
  ],
  customData: {},
  customEventType: '',
  extraData: {
    actions: [
      {
        action: ''
      }
    ],
    author: {
      userFullName: '',
      userId: ''
    },
    links: [
      {
        placeholder: '',
        resourceId: '',
        resourceType: ''
      }
    ],
    mentions: {},
    tables: [
      {
        footer: '',
        title: '',
        type: ''
      }
    ]
  },
  id: '',
  message: '',
  occurredTime: '',
  triggeredBy: '',
  type: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/customers/:id/timeline');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers/:id/timeline',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    customData: {},
    customEventType: '',
    extraData: {
      actions: [{action: ''}],
      author: {userFullName: '', userId: ''},
      links: [{placeholder: '', resourceId: '', resourceType: ''}],
      mentions: {},
      tables: [{footer: '', title: '', type: ''}]
    },
    id: '',
    message: '',
    occurredTime: '',
    triggeredBy: '',
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:id/timeline';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"customData":{},"customEventType":"","extraData":{"actions":[{"action":""}],"author":{"userFullName":"","userId":""},"links":[{"placeholder":"","resourceId":"","resourceType":""}],"mentions":{},"tables":[{"footer":"","title":"","type":""}]},"id":"","message":"","occurredTime":"","triggeredBy":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers/:id/timeline',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "customData": {},\n  "customEventType": "",\n  "extraData": {\n    "actions": [\n      {\n        "action": ""\n      }\n    ],\n    "author": {\n      "userFullName": "",\n      "userId": ""\n    },\n    "links": [\n      {\n        "placeholder": "",\n        "resourceId": "",\n        "resourceType": ""\n      }\n    ],\n    "mentions": {},\n    "tables": [\n      {\n        "footer": "",\n        "title": "",\n        "type": ""\n      }\n    ]\n  },\n  "id": "",\n  "message": "",\n  "occurredTime": "",\n  "triggeredBy": "",\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/customers/:id/timeline")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:id/timeline',
  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({
  _links: [{rel: ''}],
  customData: {},
  customEventType: '',
  extraData: {
    actions: [{action: ''}],
    author: {userFullName: '', userId: ''},
    links: [{placeholder: '', resourceId: '', resourceType: ''}],
    mentions: {},
    tables: [{footer: '', title: '', type: ''}]
  },
  id: '',
  message: '',
  occurredTime: '',
  triggeredBy: '',
  type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/customers/:id/timeline',
  headers: {'content-type': 'application/json'},
  body: {
    _links: [{rel: ''}],
    customData: {},
    customEventType: '',
    extraData: {
      actions: [{action: ''}],
      author: {userFullName: '', userId: ''},
      links: [{placeholder: '', resourceId: '', resourceType: ''}],
      mentions: {},
      tables: [{footer: '', title: '', type: ''}]
    },
    id: '',
    message: '',
    occurredTime: '',
    triggeredBy: '',
    type: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/customers/:id/timeline');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _links: [
    {
      rel: ''
    }
  ],
  customData: {},
  customEventType: '',
  extraData: {
    actions: [
      {
        action: ''
      }
    ],
    author: {
      userFullName: '',
      userId: ''
    },
    links: [
      {
        placeholder: '',
        resourceId: '',
        resourceType: ''
      }
    ],
    mentions: {},
    tables: [
      {
        footer: '',
        title: '',
        type: ''
      }
    ]
  },
  id: '',
  message: '',
  occurredTime: '',
  triggeredBy: '',
  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}}/customers/:id/timeline',
  headers: {'content-type': 'application/json'},
  data: {
    _links: [{rel: ''}],
    customData: {},
    customEventType: '',
    extraData: {
      actions: [{action: ''}],
      author: {userFullName: '', userId: ''},
      links: [{placeholder: '', resourceId: '', resourceType: ''}],
      mentions: {},
      tables: [{footer: '', title: '', type: ''}]
    },
    id: '',
    message: '',
    occurredTime: '',
    triggeredBy: '',
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:id/timeline';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":[{"rel":""}],"customData":{},"customEventType":"","extraData":{"actions":[{"action":""}],"author":{"userFullName":"","userId":""},"links":[{"placeholder":"","resourceId":"","resourceType":""}],"mentions":{},"tables":[{"footer":"","title":"","type":""}]},"id":"","message":"","occurredTime":"","triggeredBy":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"_links": @[ @{ @"rel": @"" } ],
                              @"customData": @{  },
                              @"customEventType": @"",
                              @"extraData": @{ @"actions": @[ @{ @"action": @"" } ], @"author": @{ @"userFullName": @"", @"userId": @"" }, @"links": @[ @{ @"placeholder": @"", @"resourceId": @"", @"resourceType": @"" } ], @"mentions": @{  }, @"tables": @[ @{ @"footer": @"", @"title": @"", @"type": @"" } ] },
                              @"id": @"",
                              @"message": @"",
                              @"occurredTime": @"",
                              @"triggeredBy": @"",
                              @"type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers/:id/timeline"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers/:id/timeline" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:id/timeline",
  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([
    '_links' => [
        [
                'rel' => ''
        ]
    ],
    'customData' => [
        
    ],
    'customEventType' => '',
    'extraData' => [
        'actions' => [
                [
                                'action' => ''
                ]
        ],
        'author' => [
                'userFullName' => '',
                'userId' => ''
        ],
        'links' => [
                [
                                'placeholder' => '',
                                'resourceId' => '',
                                'resourceType' => ''
                ]
        ],
        'mentions' => [
                
        ],
        'tables' => [
                [
                                'footer' => '',
                                'title' => '',
                                'type' => ''
                ]
        ]
    ],
    'id' => '',
    'message' => '',
    'occurredTime' => '',
    'triggeredBy' => '',
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/customers/:id/timeline', [
  'body' => '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "customData": {},
  "customEventType": "",
  "extraData": {
    "actions": [
      {
        "action": ""
      }
    ],
    "author": {
      "userFullName": "",
      "userId": ""
    },
    "links": [
      {
        "placeholder": "",
        "resourceId": "",
        "resourceType": ""
      }
    ],
    "mentions": {},
    "tables": [
      {
        "footer": "",
        "title": "",
        "type": ""
      }
    ]
  },
  "id": "",
  "message": "",
  "occurredTime": "",
  "triggeredBy": "",
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:id/timeline');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'customData' => [
    
  ],
  'customEventType' => '',
  'extraData' => [
    'actions' => [
        [
                'action' => ''
        ]
    ],
    'author' => [
        'userFullName' => '',
        'userId' => ''
    ],
    'links' => [
        [
                'placeholder' => '',
                'resourceId' => '',
                'resourceType' => ''
        ]
    ],
    'mentions' => [
        
    ],
    'tables' => [
        [
                'footer' => '',
                'title' => '',
                'type' => ''
        ]
    ]
  ],
  'id' => '',
  'message' => '',
  'occurredTime' => '',
  'triggeredBy' => '',
  'type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_links' => [
    [
        'rel' => ''
    ]
  ],
  'customData' => [
    
  ],
  'customEventType' => '',
  'extraData' => [
    'actions' => [
        [
                'action' => ''
        ]
    ],
    'author' => [
        'userFullName' => '',
        'userId' => ''
    ],
    'links' => [
        [
                'placeholder' => '',
                'resourceId' => '',
                'resourceType' => ''
        ]
    ],
    'mentions' => [
        
    ],
    'tables' => [
        [
                'footer' => '',
                'title' => '',
                'type' => ''
        ]
    ]
  ],
  'id' => '',
  'message' => '',
  'occurredTime' => '',
  'triggeredBy' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/customers/:id/timeline');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:id/timeline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "customData": {},
  "customEventType": "",
  "extraData": {
    "actions": [
      {
        "action": ""
      }
    ],
    "author": {
      "userFullName": "",
      "userId": ""
    },
    "links": [
      {
        "placeholder": "",
        "resourceId": "",
        "resourceType": ""
      }
    ],
    "mentions": {},
    "tables": [
      {
        "footer": "",
        "title": "",
        "type": ""
      }
    ]
  },
  "id": "",
  "message": "",
  "occurredTime": "",
  "triggeredBy": "",
  "type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:id/timeline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "customData": {},
  "customEventType": "",
  "extraData": {
    "actions": [
      {
        "action": ""
      }
    ],
    "author": {
      "userFullName": "",
      "userId": ""
    },
    "links": [
      {
        "placeholder": "",
        "resourceId": "",
        "resourceType": ""
      }
    ],
    "mentions": {},
    "tables": [
      {
        "footer": "",
        "title": "",
        "type": ""
      }
    ]
  },
  "id": "",
  "message": "",
  "occurredTime": "",
  "triggeredBy": "",
  "type": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/customers/:id/timeline", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:id/timeline"

payload = {
    "_links": [{ "rel": "" }],
    "customData": {},
    "customEventType": "",
    "extraData": {
        "actions": [{ "action": "" }],
        "author": {
            "userFullName": "",
            "userId": ""
        },
        "links": [
            {
                "placeholder": "",
                "resourceId": "",
                "resourceType": ""
            }
        ],
        "mentions": {},
        "tables": [
            {
                "footer": "",
                "title": "",
                "type": ""
            }
        ]
    },
    "id": "",
    "message": "",
    "occurredTime": "",
    "triggeredBy": "",
    "type": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:id/timeline"

payload <- "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:id/timeline")

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  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/customers/:id/timeline') do |req|
  req.body = "{\n  \"_links\": [\n    {\n      \"rel\": \"\"\n    }\n  ],\n  \"customData\": {},\n  \"customEventType\": \"\",\n  \"extraData\": {\n    \"actions\": [\n      {\n        \"action\": \"\"\n      }\n    ],\n    \"author\": {\n      \"userFullName\": \"\",\n      \"userId\": \"\"\n    },\n    \"links\": [\n      {\n        \"placeholder\": \"\",\n        \"resourceId\": \"\",\n        \"resourceType\": \"\"\n      }\n    ],\n    \"mentions\": {},\n    \"tables\": [\n      {\n        \"footer\": \"\",\n        \"title\": \"\",\n        \"type\": \"\"\n      }\n    ]\n  },\n  \"id\": \"\",\n  \"message\": \"\",\n  \"occurredTime\": \"\",\n  \"triggeredBy\": \"\",\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:id/timeline";

    let payload = json!({
        "_links": (json!({"rel": ""})),
        "customData": json!({}),
        "customEventType": "",
        "extraData": json!({
            "actions": (json!({"action": ""})),
            "author": json!({
                "userFullName": "",
                "userId": ""
            }),
            "links": (
                json!({
                    "placeholder": "",
                    "resourceId": "",
                    "resourceType": ""
                })
            ),
            "mentions": json!({}),
            "tables": (
                json!({
                    "footer": "",
                    "title": "",
                    "type": ""
                })
            )
        }),
        "id": "",
        "message": "",
        "occurredTime": "",
        "triggeredBy": "",
        "type": ""
    });

    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 '{
  "_links": [
    {
      "rel": ""
    }
  ],
  "customData": {},
  "customEventType": "",
  "extraData": {
    "actions": [
      {
        "action": ""
      }
    ],
    "author": {
      "userFullName": "",
      "userId": ""
    },
    "links": [
      {
        "placeholder": "",
        "resourceId": "",
        "resourceType": ""
      }
    ],
    "mentions": {},
    "tables": [
      {
        "footer": "",
        "title": "",
        "type": ""
      }
    ]
  },
  "id": "",
  "message": "",
  "occurredTime": "",
  "triggeredBy": "",
  "type": ""
}' |  \
  http POST {{baseUrl}}/customers/:id/timeline \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": [\n    {\n      "rel": ""\n    }\n  ],\n  "customData": {},\n  "customEventType": "",\n  "extraData": {\n    "actions": [\n      {\n        "action": ""\n      }\n    ],\n    "author": {\n      "userFullName": "",\n      "userId": ""\n    },\n    "links": [\n      {\n        "placeholder": "",\n        "resourceId": "",\n        "resourceType": ""\n      }\n    ],\n    "mentions": {},\n    "tables": [\n      {\n        "footer": "",\n        "title": "",\n        "type": ""\n      }\n    ]\n  },\n  "id": "",\n  "message": "",\n  "occurredTime": "",\n  "triggeredBy": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/customers/:id/timeline

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": [["rel": ""]],
  "customData": [],
  "customEventType": "",
  "extraData": [
    "actions": [["action": ""]],
    "author": [
      "userFullName": "",
      "userId": ""
    ],
    "links": [
      [
        "placeholder": "",
        "resourceId": "",
        "resourceType": ""
      ]
    ],
    "mentions": [],
    "tables": [
      [
        "footer": "",
        "title": "",
        "type": ""
      ]
    ]
  ],
  "id": "",
  "message": "",
  "occurredTime": "",
  "triggeredBy": "",
  "type": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:id/timeline")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/:id/timeline/:messageId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/customers/:id/timeline/:messageId")

require "http/client"

url = "{{baseUrl}}/customers/:id/timeline/:messageId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/customers/:id/timeline/:messageId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:id/timeline/:messageId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:id/timeline/:messageId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/customers/:id/timeline/:messageId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/customers/:id/timeline/:messageId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:id/timeline/:messageId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/customers/:id/timeline/:messageId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/customers/:id/timeline/:messageId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/customers/:id/timeline/:messageId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/customers/:id/timeline/:messageId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:id/timeline/:messageId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers/:id/timeline/:messageId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:id/timeline/:messageId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:id/timeline/:messageId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/customers/:id/timeline/:messageId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/customers/:id/timeline/:messageId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/customers/:id/timeline/:messageId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:id/timeline/:messageId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers/:id/timeline/:messageId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers/:id/timeline/:messageId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:id/timeline/:messageId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/customers/:id/timeline/:messageId');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:id/timeline/:messageId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:id/timeline/:messageId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:id/timeline/:messageId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:id/timeline/:messageId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/customers/:id/timeline/:messageId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:id/timeline/:messageId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:id/timeline/:messageId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:id/timeline/:messageId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/customers/:id/timeline/:messageId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:id/timeline/:messageId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/customers/:id/timeline/:messageId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/customers/:id/timeline/:messageId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:id/timeline/:messageId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/customers/:id/timeline/:messageId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/customers/:id/timeline/:messageId")

require "http/client"

url = "{{baseUrl}}/customers/:id/timeline/:messageId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/customers/:id/timeline/:messageId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customers/:id/timeline/:messageId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customers/:id/timeline/:messageId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/customers/:id/timeline/:messageId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/customers/:id/timeline/:messageId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customers/:id/timeline/:messageId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/customers/:id/timeline/:messageId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/customers/:id/timeline/:messageId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/customers/:id/timeline/:messageId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/customers/:id/timeline/:messageId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customers/:id/timeline/:messageId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customers/:id/timeline/:messageId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customers/:id/timeline/:messageId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customers/:id/timeline/:messageId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/customers/:id/timeline/:messageId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/customers/:id/timeline/:messageId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/customers/:id/timeline/:messageId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customers/:id/timeline/:messageId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customers/:id/timeline/:messageId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/customers/:id/timeline/:messageId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/customers/:id/timeline/:messageId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/customers/:id/timeline/:messageId');

echo $response->getBody();

setUrl('{{baseUrl}}/customers/:id/timeline/:messageId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/customers/:id/timeline/:messageId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/customers/:id/timeline/:messageId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/customers/:id/timeline/:messageId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/customers/:id/timeline/:messageId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/customers/:id/timeline/:messageId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/customers/:id/timeline/:messageId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/customers/:id/timeline/:messageId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/customers/:id/timeline/:messageId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/customers/:id/timeline/:messageId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/customers/:id/timeline/:messageId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/customers/:id/timeline/:messageId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/customers/:id/timeline/:messageId")! 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}}/customer-timeline-custom-events");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/customer-timeline-custom-events")

require "http/client"

url = "{{baseUrl}}/customer-timeline-custom-events"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/customer-timeline-custom-events"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/customer-timeline-custom-events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/customer-timeline-custom-events"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/customer-timeline-custom-events HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/customer-timeline-custom-events")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/customer-timeline-custom-events"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/customer-timeline-custom-events")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/customer-timeline-custom-events")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/customer-timeline-custom-events');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/customer-timeline-custom-events'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/customer-timeline-custom-events';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/customer-timeline-custom-events',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/customer-timeline-custom-events")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/customer-timeline-custom-events',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/customer-timeline-custom-events'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/customer-timeline-custom-events');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/customer-timeline-custom-events'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/customer-timeline-custom-events';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/customer-timeline-custom-events"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];