CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:companyId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/companies/:companyId")

require "http/client"

url = "{{baseUrl}}/companies/:companyId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/companies/:companyId"

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

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/companies/:companyId');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:companyId');

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:companyId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/companies/:companyId")

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

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

import requests

url = "{{baseUrl}}/companies/:companyId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:companyId")

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/companies/:companyId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/companies/:companyId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/companies/:companyId

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/companies"

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

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

package main

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

func main() {

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

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

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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}}/companies"]
                                                       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}}/companies" in

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/companies"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/companies

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/companies/:companyId/merchants")

require "http/client"

url = "{{baseUrl}}/companies/:companyId/merchants"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/companies/:companyId/merchants"

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

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/merchants")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:companyId/merchants")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/companies/:companyId/merchants');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/merchants'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/merchants")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:companyId/merchants');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/merchants'
};

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

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

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

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

 "{{baseUrl}}/companies/:companyId/merchants",
  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}}/companies/:companyId/merchants');

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/merchants');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:companyId/merchants' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/merchants' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/companies/:companyId/merchants")

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

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

import requests

url = "{{baseUrl}}/companies/:companyId/merchants"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/merchants"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:companyId/merchants")

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/companies/:companyId/merchants') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/companies/:companyId/merchants

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/companies/:companyId/merchants

import Foundation

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

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  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/merchants" {:content-type :json
                                                      :form-params {:businessLineId ""
                                                                    :companyId ""
                                                                    :description ""
                                                                    :legalEntityId ""
                                                                    :pricingPlan ""
                                                                    :reference ""
                                                                    :salesChannels []}})

require "http/client"

url = "{{baseUrl}}/merchants"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\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}}/merchants"),
    Content = new StringContent("{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\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}}/merchants");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\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/merchants HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 152

{
  "businessLineId": "",
  "companyId": "",
  "description": "",
  "legalEntityId": "",
  "pricingPlan": "",
  "reference": "",
  "salesChannels": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchants")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\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  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/merchants")
  .header("content-type", "application/json")
  .body("{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\n}")
  .asString();

const data = JSON.stringify({
  businessLineId: '',
  companyId: '',
  description: '',
  legalEntityId: '',
  pricingPlan: '',
  reference: '',
  salesChannels: []
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants',
  headers: {'content-type': 'application/json'},
  data: {
    businessLineId: '',
    companyId: '',
    description: '',
    legalEntityId: '',
    pricingPlan: '',
    reference: '',
    salesChannels: []
  }
};

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

const url = '{{baseUrl}}/merchants';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"businessLineId":"","companyId":"","description":"","legalEntityId":"","pricingPlan":"","reference":"","salesChannels":[]}'
};

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}}/merchants',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "businessLineId": "",\n  "companyId": "",\n  "description": "",\n  "legalEntityId": "",\n  "pricingPlan": "",\n  "reference": "",\n  "salesChannels": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants")
  .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/merchants',
  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({
  businessLineId: '',
  companyId: '',
  description: '',
  legalEntityId: '',
  pricingPlan: '',
  reference: '',
  salesChannels: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants',
  headers: {'content-type': 'application/json'},
  body: {
    businessLineId: '',
    companyId: '',
    description: '',
    legalEntityId: '',
    pricingPlan: '',
    reference: '',
    salesChannels: []
  },
  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}}/merchants');

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

req.type('json');
req.send({
  businessLineId: '',
  companyId: '',
  description: '',
  legalEntityId: '',
  pricingPlan: '',
  reference: '',
  salesChannels: []
});

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}}/merchants',
  headers: {'content-type': 'application/json'},
  data: {
    businessLineId: '',
    companyId: '',
    description: '',
    legalEntityId: '',
    pricingPlan: '',
    reference: '',
    salesChannels: []
  }
};

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

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

const url = '{{baseUrl}}/merchants';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"businessLineId":"","companyId":"","description":"","legalEntityId":"","pricingPlan":"","reference":"","salesChannels":[]}'
};

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 = @{ @"businessLineId": @"",
                              @"companyId": @"",
                              @"description": @"",
                              @"legalEntityId": @"",
                              @"pricingPlan": @"",
                              @"reference": @"",
                              @"salesChannels": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants"]
                                                       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}}/merchants" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\n}" in

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

 "{{baseUrl}}/merchants",
  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([
    'businessLineId' => '',
    'companyId' => '',
    'description' => '',
    'legalEntityId' => '',
    'pricingPlan' => '',
    'reference' => '',
    'salesChannels' => [
        
    ]
  ]),
  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}}/merchants', [
  'body' => '{
  "businessLineId": "",
  "companyId": "",
  "description": "",
  "legalEntityId": "",
  "pricingPlan": "",
  "reference": "",
  "salesChannels": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'businessLineId' => '',
  'companyId' => '',
  'description' => '',
  'legalEntityId' => '',
  'pricingPlan' => '',
  'reference' => '',
  'salesChannels' => [
    
  ]
]));

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

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

append(json_encode([
  'businessLineId' => '',
  'companyId' => '',
  'description' => '',
  'legalEntityId' => '',
  'pricingPlan' => '',
  'reference' => '',
  'salesChannels' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/merchants');
$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}}/merchants' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "businessLineId": "",
  "companyId": "",
  "description": "",
  "legalEntityId": "",
  "pricingPlan": "",
  "reference": "",
  "salesChannels": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "businessLineId": "",
  "companyId": "",
  "description": "",
  "legalEntityId": "",
  "pricingPlan": "",
  "reference": "",
  "salesChannels": []
}'

import http.client

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

payload = "{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/merchants"

payload = {
    "businessLineId": "",
    "companyId": "",
    "description": "",
    "legalEntityId": "",
    "pricingPlan": "",
    "reference": "",
    "salesChannels": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\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}}/merchants")

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  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\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/merchants') do |req|
  req.body = "{\n  \"businessLineId\": \"\",\n  \"companyId\": \"\",\n  \"description\": \"\",\n  \"legalEntityId\": \"\",\n  \"pricingPlan\": \"\",\n  \"reference\": \"\",\n  \"salesChannels\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "businessLineId": "",
        "companyId": "",
        "description": "",
        "legalEntityId": "",
        "pricingPlan": "",
        "reference": "",
        "salesChannels": ()
    });

    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 '{
  "businessLineId": "",
  "companyId": "",
  "description": "",
  "legalEntityId": "",
  "pricingPlan": "",
  "reference": "",
  "salesChannels": []
}' |  \
  http POST {{baseUrl}}/merchants \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "businessLineId": "",\n  "companyId": "",\n  "description": "",\n  "legalEntityId": "",\n  "pricingPlan": "",\n  "reference": "",\n  "salesChannels": []\n}' \
  --output-document \
  - {{baseUrl}}/merchants

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "businessLineId": "",
  "companyId": "",
  "description": "",
  "legalEntityId": "",
  "pricingPlan": "",
  "reference": "",
  "salesChannels": []
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/merchants"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/merchants"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/merchants

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/merchants/:merchantId")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId');

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}}/merchants/:merchantId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/merchants/:merchantId")

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId")

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/merchants/:merchantId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/merchants/:merchantId/activate")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/activate"

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

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/activate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/activate"

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

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/merchants/:merchantId/activate")
  .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}}/merchants/:merchantId/activate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/activate'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/activate")
  .post(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/merchants/:merchantId/activate');

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}}/merchants/:merchantId/activate'
};

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

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

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

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

 "{{baseUrl}}/merchants/:merchantId/activate",
  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}}/merchants/:merchantId/activate');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/activate');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/merchants/:merchantId/activate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/activate' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/activate' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/merchants/:merchantId/activate")

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId/activate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/activate"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/activate")

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/merchants/:merchantId/activate') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/merchants/:merchantId/activate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/activate

import Foundation

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

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  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/stores" {:content-type :json
                                                   :form-params {:address {:city ""
                                                                           :country ""
                                                                           :line1 ""
                                                                           :line2 ""
                                                                           :line3 ""
                                                                           :postalCode ""
                                                                           :stateOrProvince ""}
                                                                 :businessLineIds []
                                                                 :description ""
                                                                 :externalReferenceId ""
                                                                 :merchantId ""
                                                                 :phoneNumber ""
                                                                 :reference ""
                                                                 :shopperStatement ""
                                                                 :splitConfiguration {:balanceAccountId ""
                                                                                      :splitConfigurationId ""}}})

require "http/client"

url = "{{baseUrl}}/stores"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/stores"),
    Content = new StringContent("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\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}}/stores");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}")

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

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

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

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

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

}

POST /baseUrl/stores HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 407

{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "merchantId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/stores")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/stores"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\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  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/stores")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/stores")
  .header("content-type", "application/json")
  .body("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  address: {
    city: '',
    country: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  merchantId: '',
  phoneNumber: '',
  reference: '',
  shopperStatement: '',
  splitConfiguration: {
    balanceAccountId: '',
    splitConfigurationId: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/stores',
  headers: {'content-type': 'application/json'},
  data: {
    address: {
      city: '',
      country: '',
      line1: '',
      line2: '',
      line3: '',
      postalCode: '',
      stateOrProvince: ''
    },
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    merchantId: '',
    phoneNumber: '',
    reference: '',
    shopperStatement: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''}
  }
};

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

const url = '{{baseUrl}}/stores';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"","country":"","line1":"","line2":"","line3":"","postalCode":"","stateOrProvince":""},"businessLineIds":[],"description":"","externalReferenceId":"","merchantId":"","phoneNumber":"","reference":"","shopperStatement":"","splitConfiguration":{"balanceAccountId":"","splitConfigurationId":""}}'
};

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}}/stores',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": {\n    "city": "",\n    "country": "",\n    "line1": "",\n    "line2": "",\n    "line3": "",\n    "postalCode": "",\n    "stateOrProvince": ""\n  },\n  "businessLineIds": [],\n  "description": "",\n  "externalReferenceId": "",\n  "merchantId": "",\n  "phoneNumber": "",\n  "reference": "",\n  "shopperStatement": "",\n  "splitConfiguration": {\n    "balanceAccountId": "",\n    "splitConfigurationId": ""\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  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/stores")
  .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/stores',
  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({
  address: {
    city: '',
    country: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  merchantId: '',
  phoneNumber: '',
  reference: '',
  shopperStatement: '',
  splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/stores',
  headers: {'content-type': 'application/json'},
  body: {
    address: {
      city: '',
      country: '',
      line1: '',
      line2: '',
      line3: '',
      postalCode: '',
      stateOrProvince: ''
    },
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    merchantId: '',
    phoneNumber: '',
    reference: '',
    shopperStatement: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''}
  },
  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}}/stores');

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

req.type('json');
req.send({
  address: {
    city: '',
    country: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  merchantId: '',
  phoneNumber: '',
  reference: '',
  shopperStatement: '',
  splitConfiguration: {
    balanceAccountId: '',
    splitConfigurationId: ''
  }
});

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}}/stores',
  headers: {'content-type': 'application/json'},
  data: {
    address: {
      city: '',
      country: '',
      line1: '',
      line2: '',
      line3: '',
      postalCode: '',
      stateOrProvince: ''
    },
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    merchantId: '',
    phoneNumber: '',
    reference: '',
    shopperStatement: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''}
  }
};

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

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

const url = '{{baseUrl}}/stores';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"","country":"","line1":"","line2":"","line3":"","postalCode":"","stateOrProvince":""},"businessLineIds":[],"description":"","externalReferenceId":"","merchantId":"","phoneNumber":"","reference":"","shopperStatement":"","splitConfiguration":{"balanceAccountId":"","splitConfigurationId":""}}'
};

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 = @{ @"address": @{ @"city": @"", @"country": @"", @"line1": @"", @"line2": @"", @"line3": @"", @"postalCode": @"", @"stateOrProvince": @"" },
                              @"businessLineIds": @[  ],
                              @"description": @"",
                              @"externalReferenceId": @"",
                              @"merchantId": @"",
                              @"phoneNumber": @"",
                              @"reference": @"",
                              @"shopperStatement": @"",
                              @"splitConfiguration": @{ @"balanceAccountId": @"", @"splitConfigurationId": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stores"]
                                                       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}}/stores" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/stores",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'address' => [
        'city' => '',
        'country' => '',
        'line1' => '',
        'line2' => '',
        'line3' => '',
        'postalCode' => '',
        'stateOrProvince' => ''
    ],
    'businessLineIds' => [
        
    ],
    'description' => '',
    'externalReferenceId' => '',
    'merchantId' => '',
    'phoneNumber' => '',
    'reference' => '',
    'shopperStatement' => '',
    'splitConfiguration' => [
        'balanceAccountId' => '',
        'splitConfigurationId' => ''
    ]
  ]),
  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}}/stores', [
  'body' => '{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "merchantId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => [
    'city' => '',
    'country' => '',
    'line1' => '',
    'line2' => '',
    'line3' => '',
    'postalCode' => '',
    'stateOrProvince' => ''
  ],
  'businessLineIds' => [
    
  ],
  'description' => '',
  'externalReferenceId' => '',
  'merchantId' => '',
  'phoneNumber' => '',
  'reference' => '',
  'shopperStatement' => '',
  'splitConfiguration' => [
    'balanceAccountId' => '',
    'splitConfigurationId' => ''
  ]
]));

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

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

append(json_encode([
  'address' => [
    'city' => '',
    'country' => '',
    'line1' => '',
    'line2' => '',
    'line3' => '',
    'postalCode' => '',
    'stateOrProvince' => ''
  ],
  'businessLineIds' => [
    
  ],
  'description' => '',
  'externalReferenceId' => '',
  'merchantId' => '',
  'phoneNumber' => '',
  'reference' => '',
  'shopperStatement' => '',
  'splitConfiguration' => [
    'balanceAccountId' => '',
    'splitConfigurationId' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/stores');
$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}}/stores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "merchantId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "merchantId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}'

import http.client

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

payload = "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/stores"

payload = {
    "address": {
        "city": "",
        "country": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "postalCode": "",
        "stateOrProvince": ""
    },
    "businessLineIds": [],
    "description": "",
    "externalReferenceId": "",
    "merchantId": "",
    "phoneNumber": "",
    "reference": "",
    "shopperStatement": "",
    "splitConfiguration": {
        "balanceAccountId": "",
        "splitConfigurationId": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/stores') do |req|
  req.body = "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"merchantId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "address": json!({
            "city": "",
            "country": "",
            "line1": "",
            "line2": "",
            "line3": "",
            "postalCode": "",
            "stateOrProvince": ""
        }),
        "businessLineIds": (),
        "description": "",
        "externalReferenceId": "",
        "merchantId": "",
        "phoneNumber": "",
        "reference": "",
        "shopperStatement": "",
        "splitConfiguration": json!({
            "balanceAccountId": "",
            "splitConfigurationId": ""
        })
    });

    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 '{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "merchantId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}' |  \
  http POST {{baseUrl}}/stores \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": {\n    "city": "",\n    "country": "",\n    "line1": "",\n    "line2": "",\n    "line3": "",\n    "postalCode": "",\n    "stateOrProvince": ""\n  },\n  "businessLineIds": [],\n  "description": "",\n  "externalReferenceId": "",\n  "merchantId": "",\n  "phoneNumber": "",\n  "reference": "",\n  "shopperStatement": "",\n  "splitConfiguration": {\n    "balanceAccountId": "",\n    "splitConfigurationId": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/stores

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address": [
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  ],
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "merchantId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": [
    "balanceAccountId": "",
    "splitConfigurationId": ""
  ]
] as [String : Any]

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

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

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  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/merchants/:merchantId/stores" {:content-type :json
                                                                         :form-params {:address {:city ""
                                                                                                 :country ""
                                                                                                 :line1 ""
                                                                                                 :line2 ""
                                                                                                 :line3 ""
                                                                                                 :postalCode ""
                                                                                                 :stateOrProvince ""}
                                                                                       :businessLineIds []
                                                                                       :description ""
                                                                                       :externalReferenceId ""
                                                                                       :phoneNumber ""
                                                                                       :reference ""
                                                                                       :shopperStatement ""
                                                                                       :splitConfiguration {:balanceAccountId ""
                                                                                                            :splitConfigurationId ""}}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/stores"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/merchants/:merchantId/stores"),
    Content = new StringContent("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\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}}/merchants/:merchantId/stores");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/stores"

	payload := strings.NewReader("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}")

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

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

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

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

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

}

POST /baseUrl/merchants/:merchantId/stores HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 387

{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchants/:merchantId/stores")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/stores"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\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  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/stores")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/merchants/:merchantId/stores")
  .header("content-type", "application/json")
  .body("{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  address: {
    city: '',
    country: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  phoneNumber: '',
  reference: '',
  shopperStatement: '',
  splitConfiguration: {
    balanceAccountId: '',
    splitConfigurationId: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/merchants/:merchantId/stores');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/stores',
  headers: {'content-type': 'application/json'},
  data: {
    address: {
      city: '',
      country: '',
      line1: '',
      line2: '',
      line3: '',
      postalCode: '',
      stateOrProvince: ''
    },
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    phoneNumber: '',
    reference: '',
    shopperStatement: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''}
  }
};

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

const url = '{{baseUrl}}/merchants/:merchantId/stores';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"","country":"","line1":"","line2":"","line3":"","postalCode":"","stateOrProvince":""},"businessLineIds":[],"description":"","externalReferenceId":"","phoneNumber":"","reference":"","shopperStatement":"","splitConfiguration":{"balanceAccountId":"","splitConfigurationId":""}}'
};

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}}/merchants/:merchantId/stores',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": {\n    "city": "",\n    "country": "",\n    "line1": "",\n    "line2": "",\n    "line3": "",\n    "postalCode": "",\n    "stateOrProvince": ""\n  },\n  "businessLineIds": [],\n  "description": "",\n  "externalReferenceId": "",\n  "phoneNumber": "",\n  "reference": "",\n  "shopperStatement": "",\n  "splitConfiguration": {\n    "balanceAccountId": "",\n    "splitConfigurationId": ""\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  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/stores")
  .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/merchants/:merchantId/stores',
  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({
  address: {
    city: '',
    country: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  phoneNumber: '',
  reference: '',
  shopperStatement: '',
  splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/stores',
  headers: {'content-type': 'application/json'},
  body: {
    address: {
      city: '',
      country: '',
      line1: '',
      line2: '',
      line3: '',
      postalCode: '',
      stateOrProvince: ''
    },
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    phoneNumber: '',
    reference: '',
    shopperStatement: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''}
  },
  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}}/merchants/:merchantId/stores');

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

req.type('json');
req.send({
  address: {
    city: '',
    country: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  phoneNumber: '',
  reference: '',
  shopperStatement: '',
  splitConfiguration: {
    balanceAccountId: '',
    splitConfigurationId: ''
  }
});

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}}/merchants/:merchantId/stores',
  headers: {'content-type': 'application/json'},
  data: {
    address: {
      city: '',
      country: '',
      line1: '',
      line2: '',
      line3: '',
      postalCode: '',
      stateOrProvince: ''
    },
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    phoneNumber: '',
    reference: '',
    shopperStatement: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''}
  }
};

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

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

const url = '{{baseUrl}}/merchants/:merchantId/stores';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"","country":"","line1":"","line2":"","line3":"","postalCode":"","stateOrProvince":""},"businessLineIds":[],"description":"","externalReferenceId":"","phoneNumber":"","reference":"","shopperStatement":"","splitConfiguration":{"balanceAccountId":"","splitConfigurationId":""}}'
};

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 = @{ @"address": @{ @"city": @"", @"country": @"", @"line1": @"", @"line2": @"", @"line3": @"", @"postalCode": @"", @"stateOrProvince": @"" },
                              @"businessLineIds": @[  ],
                              @"description": @"",
                              @"externalReferenceId": @"",
                              @"phoneNumber": @"",
                              @"reference": @"",
                              @"shopperStatement": @"",
                              @"splitConfiguration": @{ @"balanceAccountId": @"", @"splitConfigurationId": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/stores"]
                                                       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}}/merchants/:merchantId/stores" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/merchants/:merchantId/stores",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'address' => [
        'city' => '',
        'country' => '',
        'line1' => '',
        'line2' => '',
        'line3' => '',
        'postalCode' => '',
        'stateOrProvince' => ''
    ],
    'businessLineIds' => [
        
    ],
    'description' => '',
    'externalReferenceId' => '',
    'phoneNumber' => '',
    'reference' => '',
    'shopperStatement' => '',
    'splitConfiguration' => [
        'balanceAccountId' => '',
        'splitConfigurationId' => ''
    ]
  ]),
  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}}/merchants/:merchantId/stores', [
  'body' => '{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/stores');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => [
    'city' => '',
    'country' => '',
    'line1' => '',
    'line2' => '',
    'line3' => '',
    'postalCode' => '',
    'stateOrProvince' => ''
  ],
  'businessLineIds' => [
    
  ],
  'description' => '',
  'externalReferenceId' => '',
  'phoneNumber' => '',
  'reference' => '',
  'shopperStatement' => '',
  'splitConfiguration' => [
    'balanceAccountId' => '',
    'splitConfigurationId' => ''
  ]
]));

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

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

append(json_encode([
  'address' => [
    'city' => '',
    'country' => '',
    'line1' => '',
    'line2' => '',
    'line3' => '',
    'postalCode' => '',
    'stateOrProvince' => ''
  ],
  'businessLineIds' => [
    
  ],
  'description' => '',
  'externalReferenceId' => '',
  'phoneNumber' => '',
  'reference' => '',
  'shopperStatement' => '',
  'splitConfiguration' => [
    'balanceAccountId' => '',
    'splitConfigurationId' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/stores');
$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}}/merchants/:merchantId/stores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/stores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}'

import http.client

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

payload = "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/merchants/:merchantId/stores", payload, headers)

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId/stores"

payload = {
    "address": {
        "city": "",
        "country": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "postalCode": "",
        "stateOrProvince": ""
    },
    "businessLineIds": [],
    "description": "",
    "externalReferenceId": "",
    "phoneNumber": "",
    "reference": "",
    "shopperStatement": "",
    "splitConfiguration": {
        "balanceAccountId": "",
        "splitConfigurationId": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/stores"

payload <- "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/stores")

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  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/merchants/:merchantId/stores') do |req|
  req.body = "{\n  \"address\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"phoneNumber\": \"\",\n  \"reference\": \"\",\n  \"shopperStatement\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "address": json!({
            "city": "",
            "country": "",
            "line1": "",
            "line2": "",
            "line3": "",
            "postalCode": "",
            "stateOrProvince": ""
        }),
        "businessLineIds": (),
        "description": "",
        "externalReferenceId": "",
        "phoneNumber": "",
        "reference": "",
        "shopperStatement": "",
        "splitConfiguration": json!({
            "balanceAccountId": "",
            "splitConfigurationId": ""
        })
    });

    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 '{
  "address": {
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  }
}' |  \
  http POST {{baseUrl}}/merchants/:merchantId/stores \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": {\n    "city": "",\n    "country": "",\n    "line1": "",\n    "line2": "",\n    "line3": "",\n    "postalCode": "",\n    "stateOrProvince": ""\n  },\n  "businessLineIds": [],\n  "description": "",\n  "externalReferenceId": "",\n  "phoneNumber": "",\n  "reference": "",\n  "shopperStatement": "",\n  "splitConfiguration": {\n    "balanceAccountId": "",\n    "splitConfigurationId": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/stores

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address": [
    "city": "",
    "country": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  ],
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "phoneNumber": "",
  "reference": "",
  "shopperStatement": "",
  "splitConfiguration": [
    "balanceAccountId": "",
    "splitConfigurationId": ""
  ]
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/stores"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/stores"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/stores

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/merchants/:merchantId/stores")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/stores"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/stores"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/merchants/:merchantId/stores'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/stores")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/stores');

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}}/merchants/:merchantId/stores'};

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

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

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

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

 "{{baseUrl}}/merchants/:merchantId/stores",
  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}}/merchants/:merchantId/stores');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/stores');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/stores' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/stores' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/merchants/:merchantId/stores")

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId/stores"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/stores"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/stores")

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/merchants/:merchantId/stores') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/stores

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/stores

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/stores/:storeId")

require "http/client"

url = "{{baseUrl}}/stores/:storeId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/stores/:storeId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/stores/:storeId');

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}}/stores/:storeId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/stores/:storeId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/stores/:storeId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/stores/:storeId")

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

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

import requests

url = "{{baseUrl}}/stores/:storeId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/stores/:storeId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/stores/:storeId")

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/stores/:storeId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/stores/:storeId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/stores/:storeId

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/merchants/:merchantId/stores/:storeId")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/stores/:storeId"

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

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/stores/:storeId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/stores/:storeId"

	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/merchants/:merchantId/stores/:storeId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/stores/:storeId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/stores/:storeId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/stores/:storeId');

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}}/merchants/:merchantId/stores/:storeId'
};

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

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

const url = '{{baseUrl}}/merchants/:merchantId/stores/:storeId';
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}}/merchants/:merchantId/stores/:storeId"]
                                                       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}}/merchants/:merchantId/stores/:storeId" in

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

 "{{baseUrl}}/merchants/:merchantId/stores/:storeId",
  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}}/merchants/:merchantId/stores/:storeId');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/stores/:storeId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/merchants/:merchantId/stores/:storeId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/stores/:storeId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/stores/:storeId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/merchants/:merchantId/stores/:storeId")

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId/stores/:storeId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/stores/:storeId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/stores/:storeId")

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/merchants/:merchantId/stores/:storeId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/stores/:storeId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/stores/:storeId

import Foundation

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

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  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/stores/:storeId" {:content-type :json
                                                             :form-params {:address {:city ""
                                                                                     :line1 ""
                                                                                     :line2 ""
                                                                                     :line3 ""
                                                                                     :postalCode ""
                                                                                     :stateOrProvince ""}
                                                                           :businessLineIds []
                                                                           :description ""
                                                                           :externalReferenceId ""
                                                                           :splitConfiguration {:balanceAccountId ""
                                                                                                :splitConfigurationId ""}
                                                                           :status ""}})

require "http/client"

url = "{{baseUrl}}/stores/:storeId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\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}}/stores/:storeId"),
    Content = new StringContent("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/stores/:storeId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/stores/:storeId"

	payload := strings.NewReader("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\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/stores/:storeId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 318

{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/stores/:storeId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/stores/:storeId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/stores/:storeId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/stores/:storeId")
  .header("content-type", "application/json")
  .body("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  address: {
    city: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  splitConfiguration: {
    balanceAccountId: '',
    splitConfigurationId: ''
  },
  status: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/stores/:storeId',
  headers: {'content-type': 'application/json'},
  data: {
    address: {city: '', line1: '', line2: '', line3: '', postalCode: '', stateOrProvince: ''},
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''},
    status: ''
  }
};

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

const url = '{{baseUrl}}/stores/:storeId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"","line1":"","line2":"","line3":"","postalCode":"","stateOrProvince":""},"businessLineIds":[],"description":"","externalReferenceId":"","splitConfiguration":{"balanceAccountId":"","splitConfigurationId":""},"status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/stores/:storeId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": {\n    "city": "",\n    "line1": "",\n    "line2": "",\n    "line3": "",\n    "postalCode": "",\n    "stateOrProvince": ""\n  },\n  "businessLineIds": [],\n  "description": "",\n  "externalReferenceId": "",\n  "splitConfiguration": {\n    "balanceAccountId": "",\n    "splitConfigurationId": ""\n  },\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/stores/:storeId")
  .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/stores/:storeId',
  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({
  address: {city: '', line1: '', line2: '', line3: '', postalCode: '', stateOrProvince: ''},
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''},
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/stores/:storeId',
  headers: {'content-type': 'application/json'},
  body: {
    address: {city: '', line1: '', line2: '', line3: '', postalCode: '', stateOrProvince: ''},
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''},
    status: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/stores/:storeId');

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

req.type('json');
req.send({
  address: {
    city: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  splitConfiguration: {
    balanceAccountId: '',
    splitConfigurationId: ''
  },
  status: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/stores/:storeId',
  headers: {'content-type': 'application/json'},
  data: {
    address: {city: '', line1: '', line2: '', line3: '', postalCode: '', stateOrProvince: ''},
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''},
    status: ''
  }
};

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

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

const url = '{{baseUrl}}/stores/:storeId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"","line1":"","line2":"","line3":"","postalCode":"","stateOrProvince":""},"businessLineIds":[],"description":"","externalReferenceId":"","splitConfiguration":{"balanceAccountId":"","splitConfigurationId":""},"status":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"address": @{ @"city": @"", @"line1": @"", @"line2": @"", @"line3": @"", @"postalCode": @"", @"stateOrProvince": @"" },
                              @"businessLineIds": @[  ],
                              @"description": @"",
                              @"externalReferenceId": @"",
                              @"splitConfiguration": @{ @"balanceAccountId": @"", @"splitConfigurationId": @"" },
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stores/:storeId"]
                                                       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}}/stores/:storeId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/stores/:storeId",
  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([
    'address' => [
        'city' => '',
        'line1' => '',
        'line2' => '',
        'line3' => '',
        'postalCode' => '',
        'stateOrProvince' => ''
    ],
    'businessLineIds' => [
        
    ],
    'description' => '',
    'externalReferenceId' => '',
    'splitConfiguration' => [
        'balanceAccountId' => '',
        'splitConfigurationId' => ''
    ],
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/stores/:storeId', [
  'body' => '{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/stores/:storeId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => [
    'city' => '',
    'line1' => '',
    'line2' => '',
    'line3' => '',
    'postalCode' => '',
    'stateOrProvince' => ''
  ],
  'businessLineIds' => [
    
  ],
  'description' => '',
  'externalReferenceId' => '',
  'splitConfiguration' => [
    'balanceAccountId' => '',
    'splitConfigurationId' => ''
  ],
  'status' => ''
]));

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

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

append(json_encode([
  'address' => [
    'city' => '',
    'line1' => '',
    'line2' => '',
    'line3' => '',
    'postalCode' => '',
    'stateOrProvince' => ''
  ],
  'businessLineIds' => [
    
  ],
  'description' => '',
  'externalReferenceId' => '',
  'splitConfiguration' => [
    'balanceAccountId' => '',
    'splitConfigurationId' => ''
  ],
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/stores/:storeId');
$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}}/stores/:storeId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stores/:storeId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}'

import http.client

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

payload = "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/stores/:storeId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/stores/:storeId"

payload = {
    "address": {
        "city": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "postalCode": "",
        "stateOrProvince": ""
    },
    "businessLineIds": [],
    "description": "",
    "externalReferenceId": "",
    "splitConfiguration": {
        "balanceAccountId": "",
        "splitConfigurationId": ""
    },
    "status": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/stores/:storeId"

payload <- "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\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}}/stores/:storeId")

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  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/stores/:storeId') do |req|
  req.body = "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\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}}/stores/:storeId";

    let payload = json!({
        "address": json!({
            "city": "",
            "line1": "",
            "line2": "",
            "line3": "",
            "postalCode": "",
            "stateOrProvince": ""
        }),
        "businessLineIds": (),
        "description": "",
        "externalReferenceId": "",
        "splitConfiguration": json!({
            "balanceAccountId": "",
            "splitConfigurationId": ""
        }),
        "status": ""
    });

    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 '{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}' |  \
  http PATCH {{baseUrl}}/stores/:storeId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": {\n    "city": "",\n    "line1": "",\n    "line2": "",\n    "line3": "",\n    "postalCode": "",\n    "stateOrProvince": ""\n  },\n  "businessLineIds": [],\n  "description": "",\n  "externalReferenceId": "",\n  "splitConfiguration": {\n    "balanceAccountId": "",\n    "splitConfigurationId": ""\n  },\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/stores/:storeId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address": [
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  ],
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": [
    "balanceAccountId": "",
    "splitConfigurationId": ""
  ],
  "status": ""
] as [String : Any]

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

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

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  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/merchants/:merchantId/stores/:storeId" {:content-type :json
                                                                                   :form-params {:address {:city ""
                                                                                                           :line1 ""
                                                                                                           :line2 ""
                                                                                                           :line3 ""
                                                                                                           :postalCode ""
                                                                                                           :stateOrProvince ""}
                                                                                                 :businessLineIds []
                                                                                                 :description ""
                                                                                                 :externalReferenceId ""
                                                                                                 :splitConfiguration {:balanceAccountId ""
                                                                                                                      :splitConfigurationId ""}
                                                                                                 :status ""}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/stores/:storeId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\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}}/merchants/:merchantId/stores/:storeId"),
    Content = new StringContent("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/stores/:storeId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/stores/:storeId"

	payload := strings.NewReader("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\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/merchants/:merchantId/stores/:storeId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 318

{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/merchants/:merchantId/stores/:storeId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/stores/:storeId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/stores/:storeId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/merchants/:merchantId/stores/:storeId")
  .header("content-type", "application/json")
  .body("{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  address: {
    city: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  splitConfiguration: {
    balanceAccountId: '',
    splitConfigurationId: ''
  },
  status: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/merchants/:merchantId/stores/:storeId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/stores/:storeId',
  headers: {'content-type': 'application/json'},
  data: {
    address: {city: '', line1: '', line2: '', line3: '', postalCode: '', stateOrProvince: ''},
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''},
    status: ''
  }
};

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

const url = '{{baseUrl}}/merchants/:merchantId/stores/:storeId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"","line1":"","line2":"","line3":"","postalCode":"","stateOrProvince":""},"businessLineIds":[],"description":"","externalReferenceId":"","splitConfiguration":{"balanceAccountId":"","splitConfigurationId":""},"status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/merchants/:merchantId/stores/:storeId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": {\n    "city": "",\n    "line1": "",\n    "line2": "",\n    "line3": "",\n    "postalCode": "",\n    "stateOrProvince": ""\n  },\n  "businessLineIds": [],\n  "description": "",\n  "externalReferenceId": "",\n  "splitConfiguration": {\n    "balanceAccountId": "",\n    "splitConfigurationId": ""\n  },\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/stores/:storeId")
  .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/merchants/:merchantId/stores/:storeId',
  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({
  address: {city: '', line1: '', line2: '', line3: '', postalCode: '', stateOrProvince: ''},
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''},
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/stores/:storeId',
  headers: {'content-type': 'application/json'},
  body: {
    address: {city: '', line1: '', line2: '', line3: '', postalCode: '', stateOrProvince: ''},
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''},
    status: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/merchants/:merchantId/stores/:storeId');

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

req.type('json');
req.send({
  address: {
    city: '',
    line1: '',
    line2: '',
    line3: '',
    postalCode: '',
    stateOrProvince: ''
  },
  businessLineIds: [],
  description: '',
  externalReferenceId: '',
  splitConfiguration: {
    balanceAccountId: '',
    splitConfigurationId: ''
  },
  status: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/stores/:storeId',
  headers: {'content-type': 'application/json'},
  data: {
    address: {city: '', line1: '', line2: '', line3: '', postalCode: '', stateOrProvince: ''},
    businessLineIds: [],
    description: '',
    externalReferenceId: '',
    splitConfiguration: {balanceAccountId: '', splitConfigurationId: ''},
    status: ''
  }
};

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

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

const url = '{{baseUrl}}/merchants/:merchantId/stores/:storeId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"","line1":"","line2":"","line3":"","postalCode":"","stateOrProvince":""},"businessLineIds":[],"description":"","externalReferenceId":"","splitConfiguration":{"balanceAccountId":"","splitConfigurationId":""},"status":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"address": @{ @"city": @"", @"line1": @"", @"line2": @"", @"line3": @"", @"postalCode": @"", @"stateOrProvince": @"" },
                              @"businessLineIds": @[  ],
                              @"description": @"",
                              @"externalReferenceId": @"",
                              @"splitConfiguration": @{ @"balanceAccountId": @"", @"splitConfigurationId": @"" },
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/stores/:storeId"]
                                                       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}}/merchants/:merchantId/stores/:storeId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/merchants/:merchantId/stores/:storeId",
  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([
    'address' => [
        'city' => '',
        'line1' => '',
        'line2' => '',
        'line3' => '',
        'postalCode' => '',
        'stateOrProvince' => ''
    ],
    'businessLineIds' => [
        
    ],
    'description' => '',
    'externalReferenceId' => '',
    'splitConfiguration' => [
        'balanceAccountId' => '',
        'splitConfigurationId' => ''
    ],
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/merchants/:merchantId/stores/:storeId', [
  'body' => '{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/stores/:storeId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => [
    'city' => '',
    'line1' => '',
    'line2' => '',
    'line3' => '',
    'postalCode' => '',
    'stateOrProvince' => ''
  ],
  'businessLineIds' => [
    
  ],
  'description' => '',
  'externalReferenceId' => '',
  'splitConfiguration' => [
    'balanceAccountId' => '',
    'splitConfigurationId' => ''
  ],
  'status' => ''
]));

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

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

append(json_encode([
  'address' => [
    'city' => '',
    'line1' => '',
    'line2' => '',
    'line3' => '',
    'postalCode' => '',
    'stateOrProvince' => ''
  ],
  'businessLineIds' => [
    
  ],
  'description' => '',
  'externalReferenceId' => '',
  'splitConfiguration' => [
    'balanceAccountId' => '',
    'splitConfigurationId' => ''
  ],
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/stores/:storeId');
$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}}/merchants/:merchantId/stores/:storeId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/stores/:storeId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}'

import http.client

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

payload = "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/merchants/:merchantId/stores/:storeId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId/stores/:storeId"

payload = {
    "address": {
        "city": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "postalCode": "",
        "stateOrProvince": ""
    },
    "businessLineIds": [],
    "description": "",
    "externalReferenceId": "",
    "splitConfiguration": {
        "balanceAccountId": "",
        "splitConfigurationId": ""
    },
    "status": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/stores/:storeId"

payload <- "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\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}}/merchants/:merchantId/stores/:storeId")

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  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/merchants/:merchantId/stores/:storeId') do |req|
  req.body = "{\n  \"address\": {\n    \"city\": \"\",\n    \"line1\": \"\",\n    \"line2\": \"\",\n    \"line3\": \"\",\n    \"postalCode\": \"\",\n    \"stateOrProvince\": \"\"\n  },\n  \"businessLineIds\": [],\n  \"description\": \"\",\n  \"externalReferenceId\": \"\",\n  \"splitConfiguration\": {\n    \"balanceAccountId\": \"\",\n    \"splitConfigurationId\": \"\"\n  },\n  \"status\": \"\"\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}}/merchants/:merchantId/stores/:storeId";

    let payload = json!({
        "address": json!({
            "city": "",
            "line1": "",
            "line2": "",
            "line3": "",
            "postalCode": "",
            "stateOrProvince": ""
        }),
        "businessLineIds": (),
        "description": "",
        "externalReferenceId": "",
        "splitConfiguration": json!({
            "balanceAccountId": "",
            "splitConfigurationId": ""
        }),
        "status": ""
    });

    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 '{
  "address": {
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  },
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": {
    "balanceAccountId": "",
    "splitConfigurationId": ""
  },
  "status": ""
}' |  \
  http PATCH {{baseUrl}}/merchants/:merchantId/stores/:storeId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": {\n    "city": "",\n    "line1": "",\n    "line2": "",\n    "line3": "",\n    "postalCode": "",\n    "stateOrProvince": ""\n  },\n  "businessLineIds": [],\n  "description": "",\n  "externalReferenceId": "",\n  "splitConfiguration": {\n    "balanceAccountId": "",\n    "splitConfigurationId": ""\n  },\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/stores/:storeId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address": [
    "city": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "postalCode": "",
    "stateOrProvince": ""
  ],
  "businessLineIds": [],
  "description": "",
  "externalReferenceId": "",
  "splitConfiguration": [
    "balanceAccountId": "",
    "splitConfigurationId": ""
  ],
  "status": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/stores/:storeId")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins");

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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins" {:content-type :json
                                                                                                                :form-params {:_links {:self {:href ""}}
                                                                                                                              :domain ""
                                                                                                                              :id ""}})

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"),
    Content = new StringContent("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"

	payload := strings.NewReader("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 86

{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: {
    self: {
      href: ''
    }
  },
  domain: '',
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins',
  headers: {'content-type': 'application/json'},
  data: {_links: {self: {href: ''}}, domain: '', id: ''}
};

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":{"self":{"href":""}},"domain":"","id":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": {\n    "self": {\n      "href": ""\n    }\n  },\n  "domain": "",\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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")
  .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/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins',
  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: {self: {href: ''}}, domain: '', id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins',
  headers: {'content-type': 'application/json'},
  body: {_links: {self: {href: ''}}, domain: '', 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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins');

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

req.type('json');
req.send({
  _links: {
    self: {
      href: ''
    }
  },
  domain: '',
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins',
  headers: {'content-type': 'application/json'},
  data: {_links: {self: {href: ''}}, domain: '', id: ''}
};

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

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":{"self":{"href":""}},"domain":"","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": @{ @"self": @{ @"href": @"" } },
                              @"domain": @"",
                              @"id": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}" in

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

 "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins",
  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' => [
        'self' => [
                'href' => ''
        ]
    ],
    'domain' => '',
    '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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins', [
  'body' => '{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    'self' => [
        'href' => ''
    ]
  ],
  'domain' => '',
  'id' => ''
]));

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

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

append(json_encode([
  '_links' => [
    'self' => [
        'href' => ''
    ]
  ],
  'domain' => '',
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins');
$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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}'

import http.client

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

payload = "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}"

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

conn.request("POST", "/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins", payload, headers)

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

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

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"

payload = {
    "_links": { "self": { "href": "" } },
    "domain": "",
    "id": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"

payload <- "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")

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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins') do |req|
  req.body = "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins";

    let payload = json!({
        "_links": json!({"self": json!({"href": ""})}),
        "domain": "",
        "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": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}' |  \
  http POST {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": {\n    "self": {\n      "href": ""\n    }\n  },\n  "domain": "",\n  "id": ""\n}' \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": ["self": ["href": ""]],
  "domain": "",
  "id": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

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

var client = new RestClient("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

	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/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId',
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"]
                                                       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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId" in

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

 "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId",
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

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

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

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

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/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId";

    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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")! 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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"

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

var client = new RestClient("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"

	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/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins'
};

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins'
};

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

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"]
                                                       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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins" in

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

 "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins",
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins');

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")

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

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

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")

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/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins")! 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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

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

var client = new RestClient("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

	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/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"]
                                                       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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId" in

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

 "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId",
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

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

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

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

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/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")! 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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins");

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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins" {:content-type :json
                                                                                                                 :form-params {:_links {:self {:href ""}}
                                                                                                                               :domain ""
                                                                                                                               :id ""}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"),
    Content = new StringContent("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"

	payload := strings.NewReader("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 86

{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: {
    self: {
      href: ''
    }
  },
  domain: '',
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins',
  headers: {'content-type': 'application/json'},
  data: {_links: {self: {href: ''}}, domain: '', id: ''}
};

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

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":{"self":{"href":""}},"domain":"","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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": {\n    "self": {\n      "href": ""\n    }\n  },\n  "domain": "",\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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")
  .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/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins',
  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: {self: {href: ''}}, domain: '', id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins',
  headers: {'content-type': 'application/json'},
  body: {_links: {self: {href: ''}}, domain: '', 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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins');

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

req.type('json');
req.send({
  _links: {
    self: {
      href: ''
    }
  },
  domain: '',
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins',
  headers: {'content-type': 'application/json'},
  data: {_links: {self: {href: ''}}, domain: '', id: ''}
};

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

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

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":{"self":{"href":""}},"domain":"","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": @{ @"self": @{ @"href": @"" } },
                              @"domain": @"",
                              @"id": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"]
                                                       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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}" in

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

 "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins",
  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' => [
        'self' => [
                'href' => ''
        ]
    ],
    'domain' => '',
    '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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins', [
  'body' => '{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    'self' => [
        'href' => ''
    ]
  ],
  'domain' => '',
  'id' => ''
]));

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

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

append(json_encode([
  '_links' => [
    'self' => [
        'href' => ''
    ]
  ],
  'domain' => '',
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins');
$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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}'

import http.client

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

payload = "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}"

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

conn.request("POST", "/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins", payload, headers)

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"

payload = {
    "_links": { "self": { "href": "" } },
    "domain": "",
    "id": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"

payload <- "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")

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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins') do |req|
  req.body = "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins";

    let payload = json!({
        "_links": json!({"self": json!({"href": ""})}),
        "domain": "",
        "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": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}' |  \
  http POST {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": {\n    "self": {\n      "href": ""\n    }\n  },\n  "domain": "",\n  "id": ""\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": ["self": ["href": ""]],
  "domain": "",
  "id": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")! 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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

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

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

	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/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"))
    .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId',
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

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

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"]
                                                       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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId" in

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

 "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId",
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

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/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId";

    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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")! 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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"

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

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"

	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/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"))
    .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")
  .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins'
};

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

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins');

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins'
};

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

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

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"]
                                                       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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins" in

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

 "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins",
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")

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/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins")! 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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

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

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

	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/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"))
    .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId'
};

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

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

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"]
                                                       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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId" in

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

 "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId",
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

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

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

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")

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/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/allowedOrigins/:originId")! 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}}/companies/:companyId/apiCredentials");

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  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/companies/:companyId/apiCredentials" {:content-type :json
                                                                                :form-params {:allowedOrigins []
                                                                                              :associatedMerchantAccounts []
                                                                                              :description ""
                                                                                              :roles []}})

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/companies/:companyId/apiCredentials"),
    Content = new StringContent("{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:companyId/apiCredentials");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials"

	payload := strings.NewReader("{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\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/companies/:companyId/apiCredentials HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 98

{
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/companies/:companyId/apiCredentials")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:companyId/apiCredentials"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\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  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/companies/:companyId/apiCredentials")
  .header("content-type", "application/json")
  .body("{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
  .asString();

const data = JSON.stringify({
  allowedOrigins: [],
  associatedMerchantAccounts: [],
  description: '',
  roles: []
});

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

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

xhr.open('POST', '{{baseUrl}}/companies/:companyId/apiCredentials');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials',
  headers: {'content-type': 'application/json'},
  data: {allowedOrigins: [], associatedMerchantAccounts: [], description: '', roles: []}
};

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allowedOrigins":[],"associatedMerchantAccounts":[],"description":"","roles":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/companies/:companyId/apiCredentials',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "allowedOrigins": [],\n  "associatedMerchantAccounts": [],\n  "description": "",\n  "roles": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials")
  .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/companies/:companyId/apiCredentials',
  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({allowedOrigins: [], associatedMerchantAccounts: [], description: '', roles: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials',
  headers: {'content-type': 'application/json'},
  body: {allowedOrigins: [], associatedMerchantAccounts: [], description: '', roles: []},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/companies/:companyId/apiCredentials');

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

req.type('json');
req.send({
  allowedOrigins: [],
  associatedMerchantAccounts: [],
  description: '',
  roles: []
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials',
  headers: {'content-type': 'application/json'},
  data: {allowedOrigins: [], associatedMerchantAccounts: [], description: '', roles: []}
};

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

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allowedOrigins":[],"associatedMerchantAccounts":[],"description":"","roles":[]}'
};

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 = @{ @"allowedOrigins": @[  ],
                              @"associatedMerchantAccounts": @[  ],
                              @"description": @"",
                              @"roles": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:companyId/apiCredentials"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/companies/:companyId/apiCredentials" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}" in

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

 "{{baseUrl}}/companies/:companyId/apiCredentials",
  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([
    'allowedOrigins' => [
        
    ],
    'associatedMerchantAccounts' => [
        
    ],
    'description' => '',
    'roles' => [
        
    ]
  ]),
  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}}/companies/:companyId/apiCredentials', [
  'body' => '{
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'allowedOrigins' => [
    
  ],
  'associatedMerchantAccounts' => [
    
  ],
  'description' => '',
  'roles' => [
    
  ]
]));

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

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

append(json_encode([
  'allowedOrigins' => [
    
  ],
  'associatedMerchantAccounts' => [
    
  ],
  'description' => '',
  'roles' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/companies/:companyId/apiCredentials');
$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}}/companies/:companyId/apiCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}'

import http.client

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

payload = "{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}"

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

conn.request("POST", "/baseUrl/companies/:companyId/apiCredentials", payload, headers)

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

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

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials"

payload = {
    "allowedOrigins": [],
    "associatedMerchantAccounts": [],
    "description": "",
    "roles": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials"

payload <- "{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/companies/:companyId/apiCredentials")

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  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/companies/:companyId/apiCredentials') do |req|
  req.body = "{\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "allowedOrigins": (),
        "associatedMerchantAccounts": (),
        "description": "",
        "roles": ()
    });

    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 '{
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}' |  \
  http POST {{baseUrl}}/companies/:companyId/apiCredentials \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "allowedOrigins": [],\n  "associatedMerchantAccounts": [],\n  "description": "",\n  "roles": []\n}' \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/companies/:companyId/apiCredentials")

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials"

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

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:companyId/apiCredentials")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/companies/:companyId/apiCredentials');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:companyId/apiCredentials');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials'
};

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

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

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

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

 "{{baseUrl}}/companies/:companyId/apiCredentials",
  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}}/companies/:companyId/apiCredentials');

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:companyId/apiCredentials' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/companies/:companyId/apiCredentials")

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

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

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:companyId/apiCredentials")

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/companies/:companyId/apiCredentials') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/companies/:companyId/apiCredentials

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"

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

var client = new RestClient("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"

	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/companies/:companyId/apiCredentials/:apiCredentialId HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId'
};

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

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

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId';
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}}/companies/:companyId/apiCredentials/:apiCredentialId"]
                                                       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}}/companies/:companyId/apiCredentials/:apiCredentialId" in

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

 "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId",
  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}}/companies/:companyId/apiCredentials/:apiCredentialId');

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId")

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

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")

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/companies/:companyId/apiCredentials/:apiCredentialId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")! 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}}/companies/:companyId/apiCredentials/:apiCredentialId");

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  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId" {:content-type :json
                                                                                                  :form-params {:active false
                                                                                                                :allowedOrigins []
                                                                                                                :associatedMerchantAccounts []
                                                                                                                :description ""
                                                                                                                :roles []}})

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/companies/:companyId/apiCredentials/:apiCredentialId"),
    Content = new StringContent("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"

	payload := strings.NewReader("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\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/companies/:companyId/apiCredentials/:apiCredentialId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 117

{
  "active": false,
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\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  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")
  .header("content-type", "application/json")
  .body("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
  .asString();

const data = JSON.stringify({
  active: false,
  allowedOrigins: [],
  associatedMerchantAccounts: [],
  description: '',
  roles: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    allowedOrigins: [],
    associatedMerchantAccounts: [],
    description: '',
    roles: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"allowedOrigins":[],"associatedMerchantAccounts":[],"description":"","roles":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "active": false,\n  "allowedOrigins": [],\n  "associatedMerchantAccounts": [],\n  "description": "",\n  "roles": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")
  .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/companies/:companyId/apiCredentials/:apiCredentialId',
  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({
  active: false,
  allowedOrigins: [],
  associatedMerchantAccounts: [],
  description: '',
  roles: []
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId',
  headers: {'content-type': 'application/json'},
  body: {
    active: false,
    allowedOrigins: [],
    associatedMerchantAccounts: [],
    description: '',
    roles: []
  },
  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}}/companies/:companyId/apiCredentials/:apiCredentialId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  active: false,
  allowedOrigins: [],
  associatedMerchantAccounts: [],
  description: '',
  roles: []
});

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}}/companies/:companyId/apiCredentials/:apiCredentialId',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    allowedOrigins: [],
    associatedMerchantAccounts: [],
    description: '',
    roles: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"allowedOrigins":[],"associatedMerchantAccounts":[],"description":"","roles":[]}'
};

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 = @{ @"active": @NO,
                              @"allowedOrigins": @[  ],
                              @"associatedMerchantAccounts": @[  ],
                              @"description": @"",
                              @"roles": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"]
                                                       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}}/companies/:companyId/apiCredentials/:apiCredentialId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId",
  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([
    'active' => null,
    'allowedOrigins' => [
        
    ],
    'associatedMerchantAccounts' => [
        
    ],
    'description' => '',
    'roles' => [
        
    ]
  ]),
  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}}/companies/:companyId/apiCredentials/:apiCredentialId', [
  'body' => '{
  "active": false,
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'active' => null,
  'allowedOrigins' => [
    
  ],
  'associatedMerchantAccounts' => [
    
  ],
  'description' => '',
  'roles' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'active' => null,
  'allowedOrigins' => [
    
  ],
  'associatedMerchantAccounts' => [
    
  ],
  'description' => '',
  'roles' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId');
$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}}/companies/:companyId/apiCredentials/:apiCredentialId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"

payload = {
    "active": False,
    "allowedOrigins": [],
    "associatedMerchantAccounts": [],
    "description": "",
    "roles": []
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId"

payload <- "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/companies/:companyId/apiCredentials/:apiCredentialId")

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  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\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/companies/:companyId/apiCredentials/:apiCredentialId') do |req|
  req.body = "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"associatedMerchantAccounts\": [],\n  \"description\": \"\",\n  \"roles\": []\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId";

    let payload = json!({
        "active": false,
        "allowedOrigins": (),
        "associatedMerchantAccounts": (),
        "description": "",
        "roles": ()
    });

    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 '{
  "active": false,
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
}' |  \
  http PATCH {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "active": false,\n  "allowedOrigins": [],\n  "associatedMerchantAccounts": [],\n  "description": "",\n  "roles": []\n}' \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "active": false,
  "allowedOrigins": [],
  "associatedMerchantAccounts": [],
  "description": "",
  "roles": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/merchants/:merchantId/apiCredentials");

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  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/merchants/:merchantId/apiCredentials" {:content-type :json
                                                                                 :form-params {:allowedOrigins []
                                                                                               :description ""
                                                                                               :roles []}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/merchants/:merchantId/apiCredentials"),
    Content = new StringContent("{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/merchants/:merchantId/apiCredentials");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials"

	payload := strings.NewReader("{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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/merchants/:merchantId/apiCredentials HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 62

{
  "allowedOrigins": [],
  "description": "",
  "roles": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchants/:merchantId/apiCredentials")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/merchants/:merchantId/apiCredentials")
  .header("content-type", "application/json")
  .body("{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
  .asString();

const data = JSON.stringify({
  allowedOrigins: [],
  description: '',
  roles: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/merchants/:merchantId/apiCredentials');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials',
  headers: {'content-type': 'application/json'},
  data: {allowedOrigins: [], description: '', roles: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allowedOrigins":[],"description":"","roles":[]}'
};

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}}/merchants/:merchantId/apiCredentials',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "allowedOrigins": [],\n  "description": "",\n  "roles": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials")
  .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/merchants/:merchantId/apiCredentials',
  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({allowedOrigins: [], description: '', roles: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials',
  headers: {'content-type': 'application/json'},
  body: {allowedOrigins: [], description: '', roles: []},
  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}}/merchants/:merchantId/apiCredentials');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  allowedOrigins: [],
  description: '',
  roles: []
});

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}}/merchants/:merchantId/apiCredentials',
  headers: {'content-type': 'application/json'},
  data: {allowedOrigins: [], description: '', roles: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allowedOrigins":[],"description":"","roles":[]}'
};

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 = @{ @"allowedOrigins": @[  ],
                              @"description": @"",
                              @"roles": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/apiCredentials"]
                                                       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}}/merchants/:merchantId/apiCredentials" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/apiCredentials",
  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([
    'allowedOrigins' => [
        
    ],
    'description' => '',
    'roles' => [
        
    ]
  ]),
  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}}/merchants/:merchantId/apiCredentials', [
  'body' => '{
  "allowedOrigins": [],
  "description": "",
  "roles": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'allowedOrigins' => [
    
  ],
  'description' => '',
  'roles' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'allowedOrigins' => [
    
  ],
  'description' => '',
  'roles' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials');
$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}}/merchants/:merchantId/apiCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allowedOrigins": [],
  "description": "",
  "roles": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allowedOrigins": [],
  "description": "",
  "roles": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/merchants/:merchantId/apiCredentials", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials"

payload = {
    "allowedOrigins": [],
    "description": "",
    "roles": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials"

payload <- "{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/merchants/:merchantId/apiCredentials")

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  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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/merchants/:merchantId/apiCredentials') do |req|
  req.body = "{\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/apiCredentials";

    let payload = json!({
        "allowedOrigins": (),
        "description": "",
        "roles": ()
    });

    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 '{
  "allowedOrigins": [],
  "description": "",
  "roles": []
}' |  \
  http POST {{baseUrl}}/merchants/:merchantId/apiCredentials \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "allowedOrigins": [],\n  "description": "",\n  "roles": []\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "allowedOrigins": [],
  "description": "",
  "roles": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials")! 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}}/merchants/:merchantId/apiCredentials");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/merchants/:merchantId/apiCredentials")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials"

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}}/merchants/:merchantId/apiCredentials"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/apiCredentials");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials"

	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/merchants/:merchantId/apiCredentials HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/merchants/:merchantId/apiCredentials")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials"))
    .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}}/merchants/:merchantId/apiCredentials")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/merchants/:merchantId/apiCredentials")
  .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}}/merchants/:merchantId/apiCredentials');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials';
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}}/merchants/:merchantId/apiCredentials',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/apiCredentials',
  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}}/merchants/:merchantId/apiCredentials'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/apiCredentials');

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}}/merchants/:merchantId/apiCredentials'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials';
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}}/merchants/:merchantId/apiCredentials"]
                                                       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}}/merchants/:merchantId/apiCredentials" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/apiCredentials",
  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}}/merchants/:merchantId/apiCredentials');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/merchants/:merchantId/apiCredentials")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/apiCredentials")

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/merchants/:merchantId/apiCredentials') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/apiCredentials";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/apiCredentials

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials")! 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}}/merchants/:merchantId/apiCredentials/:apiCredentialId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"

	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/merchants/:merchantId/apiCredentials/:apiCredentialId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"))
    .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")
  .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId',
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId');

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId"]
                                                       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}}/merchants/:merchantId/apiCredentials/:apiCredentialId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId",
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")

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/merchants/:merchantId/apiCredentials/:apiCredentialId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")! 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}}/merchants/:merchantId/apiCredentials/:apiCredentialId");

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  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId" {:content-type :json
                                                                                                   :form-params {:active false
                                                                                                                 :allowedOrigins []
                                                                                                                 :description ""
                                                                                                                 :roles []}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/merchants/:merchantId/apiCredentials/:apiCredentialId"),
    Content = new StringContent("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/merchants/:merchantId/apiCredentials/:apiCredentialId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"

	payload := strings.NewReader("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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/merchants/:merchantId/apiCredentials/:apiCredentialId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "active": false,
  "allowedOrigins": [],
  "description": "",
  "roles": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")
  .header("content-type", "application/json")
  .body("{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
  .asString();

const data = JSON.stringify({
  active: false,
  allowedOrigins: [],
  description: '',
  roles: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId',
  headers: {'content-type': 'application/json'},
  data: {active: false, allowedOrigins: [], description: '', roles: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"allowedOrigins":[],"description":"","roles":[]}'
};

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "active": false,\n  "allowedOrigins": [],\n  "description": "",\n  "roles": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")
  .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/merchants/:merchantId/apiCredentials/:apiCredentialId',
  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({active: false, allowedOrigins: [], description: '', roles: []}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId',
  headers: {'content-type': 'application/json'},
  body: {active: false, allowedOrigins: [], description: '', roles: []},
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  active: false,
  allowedOrigins: [],
  description: '',
  roles: []
});

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId',
  headers: {'content-type': 'application/json'},
  data: {active: false, allowedOrigins: [], description: '', roles: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"allowedOrigins":[],"description":"","roles":[]}'
};

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 = @{ @"active": @NO,
                              @"allowedOrigins": @[  ],
                              @"description": @"",
                              @"roles": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"]
                                                       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}}/merchants/:merchantId/apiCredentials/:apiCredentialId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId",
  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([
    'active' => null,
    'allowedOrigins' => [
        
    ],
    'description' => '',
    'roles' => [
        
    ]
  ]),
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId', [
  'body' => '{
  "active": false,
  "allowedOrigins": [],
  "description": "",
  "roles": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'active' => null,
  'allowedOrigins' => [
    
  ],
  'description' => '',
  'roles' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'active' => null,
  'allowedOrigins' => [
    
  ],
  'description' => '',
  'roles' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId');
$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}}/merchants/:merchantId/apiCredentials/:apiCredentialId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "allowedOrigins": [],
  "description": "",
  "roles": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "allowedOrigins": [],
  "description": "",
  "roles": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"

payload = {
    "active": False,
    "allowedOrigins": [],
    "description": "",
    "roles": []
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId"

payload <- "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/merchants/:merchantId/apiCredentials/:apiCredentialId")

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  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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/merchants/:merchantId/apiCredentials/:apiCredentialId') do |req|
  req.body = "{\n  \"active\": false,\n  \"allowedOrigins\": [],\n  \"description\": \"\",\n  \"roles\": []\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}}/merchants/:merchantId/apiCredentials/:apiCredentialId";

    let payload = json!({
        "active": false,
        "allowedOrigins": (),
        "description": "",
        "roles": ()
    });

    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 '{
  "active": false,
  "allowedOrigins": [],
  "description": "",
  "roles": []
}' |  \
  http PATCH {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "active": false,\n  "allowedOrigins": [],\n  "description": "",\n  "roles": []\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "active": false,
  "allowedOrigins": [],
  "description": "",
  "roles": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey")

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey"

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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey"

	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/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey"))
    .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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey")
  .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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey',
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey"]
                                                       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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey",
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey');

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey")

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/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateApiKey")! 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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey"

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey"

	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/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey"))
    .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey")
  .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey',
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey');

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey"]
                                                       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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey",
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey")

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/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateApiKey")! 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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey")

require "http/client"

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey"

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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey"

	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/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey"))
    .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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey")
  .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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey',
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey';
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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey"]
                                                       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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey",
  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}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey');

echo $response->getBody();

setUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey")

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/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/companies/:companyId/apiCredentials/:apiCredentialId/generateClientKey")! 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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey"

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey"

	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/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey"))
    .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey")
  .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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey',
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey');

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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey';
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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey"]
                                                       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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey",
  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}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey")

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/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/apiCredentials/:apiCredentialId/generateClientKey")! 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}}/me/allowedOrigins");

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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/me/allowedOrigins" {:content-type :json
                                                              :form-params {:_links {:self {:href ""}}
                                                                            :domain ""
                                                                            :id ""}})

require "http/client"

url = "{{baseUrl}}/me/allowedOrigins"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/me/allowedOrigins"),
    Content = new StringContent("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/me/allowedOrigins");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/me/allowedOrigins"

	payload := strings.NewReader("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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/me/allowedOrigins HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 86

{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/me/allowedOrigins")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/me/allowedOrigins"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/me/allowedOrigins")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/me/allowedOrigins")
  .header("content-type", "application/json")
  .body("{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  _links: {
    self: {
      href: ''
    }
  },
  domain: '',
  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}}/me/allowedOrigins');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/me/allowedOrigins',
  headers: {'content-type': 'application/json'},
  data: {_links: {self: {href: ''}}, domain: '', id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/me/allowedOrigins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":{"self":{"href":""}},"domain":"","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}}/me/allowedOrigins',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "_links": {\n    "self": {\n      "href": ""\n    }\n  },\n  "domain": "",\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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/me/allowedOrigins")
  .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/me/allowedOrigins',
  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: {self: {href: ''}}, domain: '', id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/me/allowedOrigins',
  headers: {'content-type': 'application/json'},
  body: {_links: {self: {href: ''}}, domain: '', 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}}/me/allowedOrigins');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  _links: {
    self: {
      href: ''
    }
  },
  domain: '',
  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}}/me/allowedOrigins',
  headers: {'content-type': 'application/json'},
  data: {_links: {self: {href: ''}}, domain: '', id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/me/allowedOrigins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"_links":{"self":{"href":""}},"domain":"","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": @{ @"self": @{ @"href": @"" } },
                              @"domain": @"",
                              @"id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/allowedOrigins"]
                                                       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}}/me/allowedOrigins" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/me/allowedOrigins",
  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' => [
        'self' => [
                'href' => ''
        ]
    ],
    'domain' => '',
    '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}}/me/allowedOrigins', [
  'body' => '{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/me/allowedOrigins');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '_links' => [
    'self' => [
        'href' => ''
    ]
  ],
  'domain' => '',
  'id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '_links' => [
    'self' => [
        'href' => ''
    ]
  ],
  'domain' => '',
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/me/allowedOrigins');
$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}}/me/allowedOrigins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/allowedOrigins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "_links": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\n  \"id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/me/allowedOrigins", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/me/allowedOrigins"

payload = {
    "_links": { "self": { "href": "" } },
    "domain": "",
    "id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/me/allowedOrigins"

payload <- "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/me/allowedOrigins")

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    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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/me/allowedOrigins') do |req|
  req.body = "{\n  \"_links\": {\n    \"self\": {\n      \"href\": \"\"\n    }\n  },\n  \"domain\": \"\",\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}}/me/allowedOrigins";

    let payload = json!({
        "_links": json!({"self": json!({"href": ""})}),
        "domain": "",
        "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": {
    "self": {
      "href": ""
    }
  },
  "domain": "",
  "id": ""
}' |  \
  http POST {{baseUrl}}/me/allowedOrigins \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "_links": {\n    "self": {\n      "href": ""\n    }\n  },\n  "domain": "",\n  "id": ""\n}' \
  --output-document \
  - {{baseUrl}}/me/allowedOrigins

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "_links": ["self": ["href": ""]],
  "domain": "",
  "id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/allowedOrigins")! 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}}/me");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/me")

require "http/client"

url = "{{baseUrl}}/me"

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}}/me"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/me");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/me"

	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/me HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/me"))
    .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}}/me")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/me")
  .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}}/me');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/me'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/me';
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}}/me',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/me")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/me',
  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}}/me'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/me');

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}}/me'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/me';
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}}/me"]
                                                       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}}/me" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/me",
  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}}/me');

echo $response->getBody();

setUrl('{{baseUrl}}/me');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/me');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/me' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/me' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/me")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/me"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/me"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/me")

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/me') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/me";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/me

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/me

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me")! 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}}/me/allowedOrigins/:originId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/me/allowedOrigins/:originId")

require "http/client"

url = "{{baseUrl}}/me/allowedOrigins/:originId"

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}}/me/allowedOrigins/:originId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/me/allowedOrigins/:originId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/me/allowedOrigins/:originId"

	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/me/allowedOrigins/:originId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/allowedOrigins/:originId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/me/allowedOrigins/:originId"))
    .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}}/me/allowedOrigins/:originId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/me/allowedOrigins/:originId")
  .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}}/me/allowedOrigins/:originId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/me/allowedOrigins/:originId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/me/allowedOrigins/:originId';
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}}/me/allowedOrigins/:originId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/me/allowedOrigins/:originId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/me/allowedOrigins/:originId',
  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}}/me/allowedOrigins/:originId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/me/allowedOrigins/:originId');

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}}/me/allowedOrigins/:originId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/me/allowedOrigins/:originId';
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}}/me/allowedOrigins/:originId"]
                                                       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}}/me/allowedOrigins/:originId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/me/allowedOrigins/:originId",
  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}}/me/allowedOrigins/:originId');

echo $response->getBody();

setUrl('{{baseUrl}}/me/allowedOrigins/:originId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/me/allowedOrigins/:originId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/allowedOrigins/:originId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/allowedOrigins/:originId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/me/allowedOrigins/:originId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/me/allowedOrigins/:originId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/me/allowedOrigins/:originId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/me/allowedOrigins/:originId")

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/me/allowedOrigins/:originId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/me/allowedOrigins/:originId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/me/allowedOrigins/:originId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/me/allowedOrigins/:originId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/allowedOrigins/:originId")! 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}}/me/allowedOrigins");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/me/allowedOrigins")

require "http/client"

url = "{{baseUrl}}/me/allowedOrigins"

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}}/me/allowedOrigins"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/me/allowedOrigins");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/me/allowedOrigins"

	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/me/allowedOrigins HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/allowedOrigins")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/me/allowedOrigins"))
    .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}}/me/allowedOrigins")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/me/allowedOrigins")
  .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}}/me/allowedOrigins');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/me/allowedOrigins'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/me/allowedOrigins';
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}}/me/allowedOrigins',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/me/allowedOrigins")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/me/allowedOrigins',
  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}}/me/allowedOrigins'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/me/allowedOrigins');

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}}/me/allowedOrigins'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/me/allowedOrigins';
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}}/me/allowedOrigins"]
                                                       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}}/me/allowedOrigins" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/me/allowedOrigins",
  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}}/me/allowedOrigins');

echo $response->getBody();

setUrl('{{baseUrl}}/me/allowedOrigins');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/me/allowedOrigins');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/allowedOrigins' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/allowedOrigins' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/me/allowedOrigins")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/me/allowedOrigins"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/me/allowedOrigins"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/me/allowedOrigins")

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/me/allowedOrigins') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/me/allowedOrigins";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/me/allowedOrigins

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/me/allowedOrigins

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/allowedOrigins")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/allowedOrigins/:originId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/me/allowedOrigins/:originId")

require "http/client"

url = "{{baseUrl}}/me/allowedOrigins/:originId"

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}}/me/allowedOrigins/:originId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/me/allowedOrigins/:originId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/me/allowedOrigins/:originId"

	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/me/allowedOrigins/:originId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/me/allowedOrigins/:originId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/me/allowedOrigins/:originId"))
    .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}}/me/allowedOrigins/:originId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/me/allowedOrigins/:originId")
  .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}}/me/allowedOrigins/:originId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/me/allowedOrigins/:originId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/me/allowedOrigins/:originId';
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}}/me/allowedOrigins/:originId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/me/allowedOrigins/:originId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/me/allowedOrigins/:originId',
  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}}/me/allowedOrigins/:originId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/me/allowedOrigins/:originId');

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}}/me/allowedOrigins/:originId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/me/allowedOrigins/:originId';
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}}/me/allowedOrigins/:originId"]
                                                       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}}/me/allowedOrigins/:originId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/me/allowedOrigins/:originId",
  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}}/me/allowedOrigins/:originId');

echo $response->getBody();

setUrl('{{baseUrl}}/me/allowedOrigins/:originId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/me/allowedOrigins/:originId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/allowedOrigins/:originId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/allowedOrigins/:originId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/me/allowedOrigins/:originId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/me/allowedOrigins/:originId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/me/allowedOrigins/:originId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/me/allowedOrigins/:originId")

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/me/allowedOrigins/:originId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/me/allowedOrigins/:originId";

    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}}/me/allowedOrigins/:originId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/me/allowedOrigins/:originId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/allowedOrigins/:originId")! 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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains");

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  \"domains\": [\n    \"https://example.com\"\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains" {:content-type :json
                                                                                                                            :form-params {:domains ["https://example.com"]}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"domains\": [\n    \"https://example.com\"\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains"),
    Content = new StringContent("{\n  \"domains\": [\n    \"https://example.com\"\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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domains\": [\n    \"https://example.com\"\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains"

	payload := strings.NewReader("{\n  \"domains\": [\n    \"https://example.com\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "domains": [
    "https://example.com"
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domains\": [\n    \"https://example.com\"\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domains\": [\n    \"https://example.com\"\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  \"domains\": [\n    \"https://example.com\"\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains")
  .header("content-type", "application/json")
  .body("{\n  \"domains\": [\n    \"https://example.com\"\n  ]\n}")
  .asString();

const data = JSON.stringify({
  domains: [
    'https://example.com'
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains',
  headers: {'content-type': 'application/json'},
  data: {domains: ['https://example.com']}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"domains":["https://example.com"]}'
};

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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domains": [\n    "https://example.com"\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  \"domains\": [\n    \"https://example.com\"\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains")
  .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/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains',
  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({domains: ['https://example.com']}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains',
  headers: {'content-type': 'application/json'},
  body: {domains: ['https://example.com']},
  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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domains: [
    'https://example.com'
  ]
});

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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains',
  headers: {'content-type': 'application/json'},
  data: {domains: ['https://example.com']}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"domains":["https://example.com"]}'
};

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 = @{ @"domains": @[ @"https://example.com" ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains"]
                                                       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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"domains\": [\n    \"https://example.com\"\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains",
  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([
    'domains' => [
        'https://example.com'
    ]
  ]),
  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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains', [
  'body' => '{
  "domains": [
    "https://example.com"
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domains' => [
    'https://example.com'
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domains' => [
    'https://example.com'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains');
$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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domains": [
    "https://example.com"
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domains": [
    "https://example.com"
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domains\": [\n    \"https://example.com\"\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains"

payload = { "domains": ["https://example.com"] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains"

payload <- "{\n  \"domains\": [\n    \"https://example.com\"\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains")

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  \"domains\": [\n    \"https://example.com\"\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains') do |req|
  req.body = "{\n  \"domains\": [\n    \"https://example.com\"\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains";

    let payload = json!({"domains": ("https://example.com")});

    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 '{
  "domains": [
    "https://example.com"
  ]
}' |  \
  http POST {{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "domains": [\n    "https://example.com"\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["domains": ["https://example.com"]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/addApplePayDomains")! 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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains"

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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains"

	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/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains"))
    .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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains")
  .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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains';
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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains',
  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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains');

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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains';
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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains"]
                                                       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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains",
  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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains")

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/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId/getApplePayDomains")! 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}}/merchants/:merchantId/paymentMethodSettings");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"

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}}/merchants/:merchantId/paymentMethodSettings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"

	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/merchants/:merchantId/paymentMethodSettings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"))
    .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}}/merchants/:merchantId/paymentMethodSettings")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")
  .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}}/merchants/:merchantId/paymentMethodSettings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings';
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}}/merchants/:merchantId/paymentMethodSettings',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/paymentMethodSettings',
  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}}/merchants/:merchantId/paymentMethodSettings'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings');

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}}/merchants/:merchantId/paymentMethodSettings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings';
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}}/merchants/:merchantId/paymentMethodSettings"]
                                                       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}}/merchants/:merchantId/paymentMethodSettings" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings",
  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}}/merchants/:merchantId/paymentMethodSettings');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/merchants/:merchantId/paymentMethodSettings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")

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/merchants/:merchantId/paymentMethodSettings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/paymentMethodSettings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/paymentMethodSettings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")! 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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"

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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"

	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/merchants/:merchantId/paymentMethodSettings/:paymentMethodId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"))
    .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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")
  .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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId';
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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/paymentMethodSettings/:paymentMethodId',
  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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId');

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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId';
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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"]
                                                       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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId",
  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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")

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/merchants/:merchantId/paymentMethodSettings/:paymentMethodId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")! 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}}/merchants/:merchantId/paymentMethodSettings");

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  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings" {:content-type :json
                                                                                        :form-params {:applePay {:domains []}
                                                                                                      :bcmc {:enableBcmcMobile false}
                                                                                                      :businessLineId ""
                                                                                                      :cartesBancaires {:siret ""}
                                                                                                      :countries []
                                                                                                      :currencies []
                                                                                                      :customRoutingFlags []
                                                                                                      :giroPay {:supportEmail ""}
                                                                                                      :googlePay {:merchantId ""
                                                                                                                  :reuseMerchantId false}
                                                                                                      :klarna {:autoCapture false
                                                                                                               :disputeEmail ""
                                                                                                               :region ""
                                                                                                               :supportEmail ""}
                                                                                                      :mealVoucher_FR {:conecsId ""
                                                                                                                       :siret ""
                                                                                                                       :subTypes []}
                                                                                                      :paypal {:directCapture false
                                                                                                               :payerId ""
                                                                                                               :subject ""}
                                                                                                      :reference ""
                                                                                                      :shopperInteraction ""
                                                                                                      :sofort {:currencyCode ""
                                                                                                               :logo ""}
                                                                                                      :storeId ""
                                                                                                      :swish {:swishNumber ""}
                                                                                                      :type ""
                                                                                                      :vipps {:logo ""
                                                                                                              :subscriptionCancelUrl ""}}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"),
    Content = new StringContent("{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\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}}/merchants/:merchantId/paymentMethodSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"

	payload := strings.NewReader("{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/merchants/:merchantId/paymentMethodSettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 858

{
  "applePay": {
    "domains": []
  },
  "bcmc": {
    "enableBcmcMobile": false
  },
  "businessLineId": "",
  "cartesBancaires": {
    "siret": ""
  },
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "giroPay": {
    "supportEmail": ""
  },
  "googlePay": {
    "merchantId": "",
    "reuseMerchantId": false
  },
  "klarna": {
    "autoCapture": false,
    "disputeEmail": "",
    "region": "",
    "supportEmail": ""
  },
  "mealVoucher_FR": {
    "conecsId": "",
    "siret": "",
    "subTypes": []
  },
  "paypal": {
    "directCapture": false,
    "payerId": "",
    "subject": ""
  },
  "reference": "",
  "shopperInteraction": "",
  "sofort": {
    "currencyCode": "",
    "logo": ""
  },
  "storeId": "",
  "swish": {
    "swishNumber": ""
  },
  "type": "",
  "vipps": {
    "logo": "",
    "subscriptionCancelUrl": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\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  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")
  .header("content-type", "application/json")
  .body("{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  applePay: {
    domains: []
  },
  bcmc: {
    enableBcmcMobile: false
  },
  businessLineId: '',
  cartesBancaires: {
    siret: ''
  },
  countries: [],
  currencies: [],
  customRoutingFlags: [],
  giroPay: {
    supportEmail: ''
  },
  googlePay: {
    merchantId: '',
    reuseMerchantId: false
  },
  klarna: {
    autoCapture: false,
    disputeEmail: '',
    region: '',
    supportEmail: ''
  },
  mealVoucher_FR: {
    conecsId: '',
    siret: '',
    subTypes: []
  },
  paypal: {
    directCapture: false,
    payerId: '',
    subject: ''
  },
  reference: '',
  shopperInteraction: '',
  sofort: {
    currencyCode: '',
    logo: ''
  },
  storeId: '',
  swish: {
    swishNumber: ''
  },
  type: '',
  vipps: {
    logo: '',
    subscriptionCancelUrl: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings',
  headers: {'content-type': 'application/json'},
  data: {
    applePay: {domains: []},
    bcmc: {enableBcmcMobile: false},
    businessLineId: '',
    cartesBancaires: {siret: ''},
    countries: [],
    currencies: [],
    customRoutingFlags: [],
    giroPay: {supportEmail: ''},
    googlePay: {merchantId: '', reuseMerchantId: false},
    klarna: {autoCapture: false, disputeEmail: '', region: '', supportEmail: ''},
    mealVoucher_FR: {conecsId: '', siret: '', subTypes: []},
    paypal: {directCapture: false, payerId: '', subject: ''},
    reference: '',
    shopperInteraction: '',
    sofort: {currencyCode: '', logo: ''},
    storeId: '',
    swish: {swishNumber: ''},
    type: '',
    vipps: {logo: '', subscriptionCancelUrl: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"applePay":{"domains":[]},"bcmc":{"enableBcmcMobile":false},"businessLineId":"","cartesBancaires":{"siret":""},"countries":[],"currencies":[],"customRoutingFlags":[],"giroPay":{"supportEmail":""},"googlePay":{"merchantId":"","reuseMerchantId":false},"klarna":{"autoCapture":false,"disputeEmail":"","region":"","supportEmail":""},"mealVoucher_FR":{"conecsId":"","siret":"","subTypes":[]},"paypal":{"directCapture":false,"payerId":"","subject":""},"reference":"","shopperInteraction":"","sofort":{"currencyCode":"","logo":""},"storeId":"","swish":{"swishNumber":""},"type":"","vipps":{"logo":"","subscriptionCancelUrl":""}}'
};

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}}/merchants/:merchantId/paymentMethodSettings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "applePay": {\n    "domains": []\n  },\n  "bcmc": {\n    "enableBcmcMobile": false\n  },\n  "businessLineId": "",\n  "cartesBancaires": {\n    "siret": ""\n  },\n  "countries": [],\n  "currencies": [],\n  "customRoutingFlags": [],\n  "giroPay": {\n    "supportEmail": ""\n  },\n  "googlePay": {\n    "merchantId": "",\n    "reuseMerchantId": false\n  },\n  "klarna": {\n    "autoCapture": false,\n    "disputeEmail": "",\n    "region": "",\n    "supportEmail": ""\n  },\n  "mealVoucher_FR": {\n    "conecsId": "",\n    "siret": "",\n    "subTypes": []\n  },\n  "paypal": {\n    "directCapture": false,\n    "payerId": "",\n    "subject": ""\n  },\n  "reference": "",\n  "shopperInteraction": "",\n  "sofort": {\n    "currencyCode": "",\n    "logo": ""\n  },\n  "storeId": "",\n  "swish": {\n    "swishNumber": ""\n  },\n  "type": "",\n  "vipps": {\n    "logo": "",\n    "subscriptionCancelUrl": ""\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  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")
  .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/merchants/:merchantId/paymentMethodSettings',
  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({
  applePay: {domains: []},
  bcmc: {enableBcmcMobile: false},
  businessLineId: '',
  cartesBancaires: {siret: ''},
  countries: [],
  currencies: [],
  customRoutingFlags: [],
  giroPay: {supportEmail: ''},
  googlePay: {merchantId: '', reuseMerchantId: false},
  klarna: {autoCapture: false, disputeEmail: '', region: '', supportEmail: ''},
  mealVoucher_FR: {conecsId: '', siret: '', subTypes: []},
  paypal: {directCapture: false, payerId: '', subject: ''},
  reference: '',
  shopperInteraction: '',
  sofort: {currencyCode: '', logo: ''},
  storeId: '',
  swish: {swishNumber: ''},
  type: '',
  vipps: {logo: '', subscriptionCancelUrl: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings',
  headers: {'content-type': 'application/json'},
  body: {
    applePay: {domains: []},
    bcmc: {enableBcmcMobile: false},
    businessLineId: '',
    cartesBancaires: {siret: ''},
    countries: [],
    currencies: [],
    customRoutingFlags: [],
    giroPay: {supportEmail: ''},
    googlePay: {merchantId: '', reuseMerchantId: false},
    klarna: {autoCapture: false, disputeEmail: '', region: '', supportEmail: ''},
    mealVoucher_FR: {conecsId: '', siret: '', subTypes: []},
    paypal: {directCapture: false, payerId: '', subject: ''},
    reference: '',
    shopperInteraction: '',
    sofort: {currencyCode: '', logo: ''},
    storeId: '',
    swish: {swishNumber: ''},
    type: '',
    vipps: {logo: '', subscriptionCancelUrl: ''}
  },
  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}}/merchants/:merchantId/paymentMethodSettings');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  applePay: {
    domains: []
  },
  bcmc: {
    enableBcmcMobile: false
  },
  businessLineId: '',
  cartesBancaires: {
    siret: ''
  },
  countries: [],
  currencies: [],
  customRoutingFlags: [],
  giroPay: {
    supportEmail: ''
  },
  googlePay: {
    merchantId: '',
    reuseMerchantId: false
  },
  klarna: {
    autoCapture: false,
    disputeEmail: '',
    region: '',
    supportEmail: ''
  },
  mealVoucher_FR: {
    conecsId: '',
    siret: '',
    subTypes: []
  },
  paypal: {
    directCapture: false,
    payerId: '',
    subject: ''
  },
  reference: '',
  shopperInteraction: '',
  sofort: {
    currencyCode: '',
    logo: ''
  },
  storeId: '',
  swish: {
    swishNumber: ''
  },
  type: '',
  vipps: {
    logo: '',
    subscriptionCancelUrl: ''
  }
});

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}}/merchants/:merchantId/paymentMethodSettings',
  headers: {'content-type': 'application/json'},
  data: {
    applePay: {domains: []},
    bcmc: {enableBcmcMobile: false},
    businessLineId: '',
    cartesBancaires: {siret: ''},
    countries: [],
    currencies: [],
    customRoutingFlags: [],
    giroPay: {supportEmail: ''},
    googlePay: {merchantId: '', reuseMerchantId: false},
    klarna: {autoCapture: false, disputeEmail: '', region: '', supportEmail: ''},
    mealVoucher_FR: {conecsId: '', siret: '', subTypes: []},
    paypal: {directCapture: false, payerId: '', subject: ''},
    reference: '',
    shopperInteraction: '',
    sofort: {currencyCode: '', logo: ''},
    storeId: '',
    swish: {swishNumber: ''},
    type: '',
    vipps: {logo: '', subscriptionCancelUrl: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"applePay":{"domains":[]},"bcmc":{"enableBcmcMobile":false},"businessLineId":"","cartesBancaires":{"siret":""},"countries":[],"currencies":[],"customRoutingFlags":[],"giroPay":{"supportEmail":""},"googlePay":{"merchantId":"","reuseMerchantId":false},"klarna":{"autoCapture":false,"disputeEmail":"","region":"","supportEmail":""},"mealVoucher_FR":{"conecsId":"","siret":"","subTypes":[]},"paypal":{"directCapture":false,"payerId":"","subject":""},"reference":"","shopperInteraction":"","sofort":{"currencyCode":"","logo":""},"storeId":"","swish":{"swishNumber":""},"type":"","vipps":{"logo":"","subscriptionCancelUrl":""}}'
};

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 = @{ @"applePay": @{ @"domains": @[  ] },
                              @"bcmc": @{ @"enableBcmcMobile": @NO },
                              @"businessLineId": @"",
                              @"cartesBancaires": @{ @"siret": @"" },
                              @"countries": @[  ],
                              @"currencies": @[  ],
                              @"customRoutingFlags": @[  ],
                              @"giroPay": @{ @"supportEmail": @"" },
                              @"googlePay": @{ @"merchantId": @"", @"reuseMerchantId": @NO },
                              @"klarna": @{ @"autoCapture": @NO, @"disputeEmail": @"", @"region": @"", @"supportEmail": @"" },
                              @"mealVoucher_FR": @{ @"conecsId": @"", @"siret": @"", @"subTypes": @[  ] },
                              @"paypal": @{ @"directCapture": @NO, @"payerId": @"", @"subject": @"" },
                              @"reference": @"",
                              @"shopperInteraction": @"",
                              @"sofort": @{ @"currencyCode": @"", @"logo": @"" },
                              @"storeId": @"",
                              @"swish": @{ @"swishNumber": @"" },
                              @"type": @"",
                              @"vipps": @{ @"logo": @"", @"subscriptionCancelUrl": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"]
                                                       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}}/merchants/:merchantId/paymentMethodSettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings",
  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([
    'applePay' => [
        'domains' => [
                
        ]
    ],
    'bcmc' => [
        'enableBcmcMobile' => null
    ],
    'businessLineId' => '',
    'cartesBancaires' => [
        'siret' => ''
    ],
    'countries' => [
        
    ],
    'currencies' => [
        
    ],
    'customRoutingFlags' => [
        
    ],
    'giroPay' => [
        'supportEmail' => ''
    ],
    'googlePay' => [
        'merchantId' => '',
        'reuseMerchantId' => null
    ],
    'klarna' => [
        'autoCapture' => null,
        'disputeEmail' => '',
        'region' => '',
        'supportEmail' => ''
    ],
    'mealVoucher_FR' => [
        'conecsId' => '',
        'siret' => '',
        'subTypes' => [
                
        ]
    ],
    'paypal' => [
        'directCapture' => null,
        'payerId' => '',
        'subject' => ''
    ],
    'reference' => '',
    'shopperInteraction' => '',
    'sofort' => [
        'currencyCode' => '',
        'logo' => ''
    ],
    'storeId' => '',
    'swish' => [
        'swishNumber' => ''
    ],
    'type' => '',
    'vipps' => [
        'logo' => '',
        'subscriptionCancelUrl' => ''
    ]
  ]),
  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}}/merchants/:merchantId/paymentMethodSettings', [
  'body' => '{
  "applePay": {
    "domains": []
  },
  "bcmc": {
    "enableBcmcMobile": false
  },
  "businessLineId": "",
  "cartesBancaires": {
    "siret": ""
  },
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "giroPay": {
    "supportEmail": ""
  },
  "googlePay": {
    "merchantId": "",
    "reuseMerchantId": false
  },
  "klarna": {
    "autoCapture": false,
    "disputeEmail": "",
    "region": "",
    "supportEmail": ""
  },
  "mealVoucher_FR": {
    "conecsId": "",
    "siret": "",
    "subTypes": []
  },
  "paypal": {
    "directCapture": false,
    "payerId": "",
    "subject": ""
  },
  "reference": "",
  "shopperInteraction": "",
  "sofort": {
    "currencyCode": "",
    "logo": ""
  },
  "storeId": "",
  "swish": {
    "swishNumber": ""
  },
  "type": "",
  "vipps": {
    "logo": "",
    "subscriptionCancelUrl": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'applePay' => [
    'domains' => [
        
    ]
  ],
  'bcmc' => [
    'enableBcmcMobile' => null
  ],
  'businessLineId' => '',
  'cartesBancaires' => [
    'siret' => ''
  ],
  'countries' => [
    
  ],
  'currencies' => [
    
  ],
  'customRoutingFlags' => [
    
  ],
  'giroPay' => [
    'supportEmail' => ''
  ],
  'googlePay' => [
    'merchantId' => '',
    'reuseMerchantId' => null
  ],
  'klarna' => [
    'autoCapture' => null,
    'disputeEmail' => '',
    'region' => '',
    'supportEmail' => ''
  ],
  'mealVoucher_FR' => [
    'conecsId' => '',
    'siret' => '',
    'subTypes' => [
        
    ]
  ],
  'paypal' => [
    'directCapture' => null,
    'payerId' => '',
    'subject' => ''
  ],
  'reference' => '',
  'shopperInteraction' => '',
  'sofort' => [
    'currencyCode' => '',
    'logo' => ''
  ],
  'storeId' => '',
  'swish' => [
    'swishNumber' => ''
  ],
  'type' => '',
  'vipps' => [
    'logo' => '',
    'subscriptionCancelUrl' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'applePay' => [
    'domains' => [
        
    ]
  ],
  'bcmc' => [
    'enableBcmcMobile' => null
  ],
  'businessLineId' => '',
  'cartesBancaires' => [
    'siret' => ''
  ],
  'countries' => [
    
  ],
  'currencies' => [
    
  ],
  'customRoutingFlags' => [
    
  ],
  'giroPay' => [
    'supportEmail' => ''
  ],
  'googlePay' => [
    'merchantId' => '',
    'reuseMerchantId' => null
  ],
  'klarna' => [
    'autoCapture' => null,
    'disputeEmail' => '',
    'region' => '',
    'supportEmail' => ''
  ],
  'mealVoucher_FR' => [
    'conecsId' => '',
    'siret' => '',
    'subTypes' => [
        
    ]
  ],
  'paypal' => [
    'directCapture' => null,
    'payerId' => '',
    'subject' => ''
  ],
  'reference' => '',
  'shopperInteraction' => '',
  'sofort' => [
    'currencyCode' => '',
    'logo' => ''
  ],
  'storeId' => '',
  'swish' => [
    'swishNumber' => ''
  ],
  'type' => '',
  'vipps' => [
    'logo' => '',
    'subscriptionCancelUrl' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings');
$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}}/merchants/:merchantId/paymentMethodSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "applePay": {
    "domains": []
  },
  "bcmc": {
    "enableBcmcMobile": false
  },
  "businessLineId": "",
  "cartesBancaires": {
    "siret": ""
  },
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "giroPay": {
    "supportEmail": ""
  },
  "googlePay": {
    "merchantId": "",
    "reuseMerchantId": false
  },
  "klarna": {
    "autoCapture": false,
    "disputeEmail": "",
    "region": "",
    "supportEmail": ""
  },
  "mealVoucher_FR": {
    "conecsId": "",
    "siret": "",
    "subTypes": []
  },
  "paypal": {
    "directCapture": false,
    "payerId": "",
    "subject": ""
  },
  "reference": "",
  "shopperInteraction": "",
  "sofort": {
    "currencyCode": "",
    "logo": ""
  },
  "storeId": "",
  "swish": {
    "swishNumber": ""
  },
  "type": "",
  "vipps": {
    "logo": "",
    "subscriptionCancelUrl": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "applePay": {
    "domains": []
  },
  "bcmc": {
    "enableBcmcMobile": false
  },
  "businessLineId": "",
  "cartesBancaires": {
    "siret": ""
  },
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "giroPay": {
    "supportEmail": ""
  },
  "googlePay": {
    "merchantId": "",
    "reuseMerchantId": false
  },
  "klarna": {
    "autoCapture": false,
    "disputeEmail": "",
    "region": "",
    "supportEmail": ""
  },
  "mealVoucher_FR": {
    "conecsId": "",
    "siret": "",
    "subTypes": []
  },
  "paypal": {
    "directCapture": false,
    "payerId": "",
    "subject": ""
  },
  "reference": "",
  "shopperInteraction": "",
  "sofort": {
    "currencyCode": "",
    "logo": ""
  },
  "storeId": "",
  "swish": {
    "swishNumber": ""
  },
  "type": "",
  "vipps": {
    "logo": "",
    "subscriptionCancelUrl": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/merchants/:merchantId/paymentMethodSettings", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"

payload = {
    "applePay": { "domains": [] },
    "bcmc": { "enableBcmcMobile": False },
    "businessLineId": "",
    "cartesBancaires": { "siret": "" },
    "countries": [],
    "currencies": [],
    "customRoutingFlags": [],
    "giroPay": { "supportEmail": "" },
    "googlePay": {
        "merchantId": "",
        "reuseMerchantId": False
    },
    "klarna": {
        "autoCapture": False,
        "disputeEmail": "",
        "region": "",
        "supportEmail": ""
    },
    "mealVoucher_FR": {
        "conecsId": "",
        "siret": "",
        "subTypes": []
    },
    "paypal": {
        "directCapture": False,
        "payerId": "",
        "subject": ""
    },
    "reference": "",
    "shopperInteraction": "",
    "sofort": {
        "currencyCode": "",
        "logo": ""
    },
    "storeId": "",
    "swish": { "swishNumber": "" },
    "type": "",
    "vipps": {
        "logo": "",
        "subscriptionCancelUrl": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings"

payload <- "{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")

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  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/merchants/:merchantId/paymentMethodSettings') do |req|
  req.body = "{\n  \"applePay\": {\n    \"domains\": []\n  },\n  \"bcmc\": {\n    \"enableBcmcMobile\": false\n  },\n  \"businessLineId\": \"\",\n  \"cartesBancaires\": {\n    \"siret\": \"\"\n  },\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"giroPay\": {\n    \"supportEmail\": \"\"\n  },\n  \"googlePay\": {\n    \"merchantId\": \"\",\n    \"reuseMerchantId\": false\n  },\n  \"klarna\": {\n    \"autoCapture\": false,\n    \"disputeEmail\": \"\",\n    \"region\": \"\",\n    \"supportEmail\": \"\"\n  },\n  \"mealVoucher_FR\": {\n    \"conecsId\": \"\",\n    \"siret\": \"\",\n    \"subTypes\": []\n  },\n  \"paypal\": {\n    \"directCapture\": false,\n    \"payerId\": \"\",\n    \"subject\": \"\"\n  },\n  \"reference\": \"\",\n  \"shopperInteraction\": \"\",\n  \"sofort\": {\n    \"currencyCode\": \"\",\n    \"logo\": \"\"\n  },\n  \"storeId\": \"\",\n  \"swish\": {\n    \"swishNumber\": \"\"\n  },\n  \"type\": \"\",\n  \"vipps\": {\n    \"logo\": \"\",\n    \"subscriptionCancelUrl\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings";

    let payload = json!({
        "applePay": json!({"domains": ()}),
        "bcmc": json!({"enableBcmcMobile": false}),
        "businessLineId": "",
        "cartesBancaires": json!({"siret": ""}),
        "countries": (),
        "currencies": (),
        "customRoutingFlags": (),
        "giroPay": json!({"supportEmail": ""}),
        "googlePay": json!({
            "merchantId": "",
            "reuseMerchantId": false
        }),
        "klarna": json!({
            "autoCapture": false,
            "disputeEmail": "",
            "region": "",
            "supportEmail": ""
        }),
        "mealVoucher_FR": json!({
            "conecsId": "",
            "siret": "",
            "subTypes": ()
        }),
        "paypal": json!({
            "directCapture": false,
            "payerId": "",
            "subject": ""
        }),
        "reference": "",
        "shopperInteraction": "",
        "sofort": json!({
            "currencyCode": "",
            "logo": ""
        }),
        "storeId": "",
        "swish": json!({"swishNumber": ""}),
        "type": "",
        "vipps": json!({
            "logo": "",
            "subscriptionCancelUrl": ""
        })
    });

    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 '{
  "applePay": {
    "domains": []
  },
  "bcmc": {
    "enableBcmcMobile": false
  },
  "businessLineId": "",
  "cartesBancaires": {
    "siret": ""
  },
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "giroPay": {
    "supportEmail": ""
  },
  "googlePay": {
    "merchantId": "",
    "reuseMerchantId": false
  },
  "klarna": {
    "autoCapture": false,
    "disputeEmail": "",
    "region": "",
    "supportEmail": ""
  },
  "mealVoucher_FR": {
    "conecsId": "",
    "siret": "",
    "subTypes": []
  },
  "paypal": {
    "directCapture": false,
    "payerId": "",
    "subject": ""
  },
  "reference": "",
  "shopperInteraction": "",
  "sofort": {
    "currencyCode": "",
    "logo": ""
  },
  "storeId": "",
  "swish": {
    "swishNumber": ""
  },
  "type": "",
  "vipps": {
    "logo": "",
    "subscriptionCancelUrl": ""
  }
}' |  \
  http POST {{baseUrl}}/merchants/:merchantId/paymentMethodSettings \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "applePay": {\n    "domains": []\n  },\n  "bcmc": {\n    "enableBcmcMobile": false\n  },\n  "businessLineId": "",\n  "cartesBancaires": {\n    "siret": ""\n  },\n  "countries": [],\n  "currencies": [],\n  "customRoutingFlags": [],\n  "giroPay": {\n    "supportEmail": ""\n  },\n  "googlePay": {\n    "merchantId": "",\n    "reuseMerchantId": false\n  },\n  "klarna": {\n    "autoCapture": false,\n    "disputeEmail": "",\n    "region": "",\n    "supportEmail": ""\n  },\n  "mealVoucher_FR": {\n    "conecsId": "",\n    "siret": "",\n    "subTypes": []\n  },\n  "paypal": {\n    "directCapture": false,\n    "payerId": "",\n    "subject": ""\n  },\n  "reference": "",\n  "shopperInteraction": "",\n  "sofort": {\n    "currencyCode": "",\n    "logo": ""\n  },\n  "storeId": "",\n  "swish": {\n    "swishNumber": ""\n  },\n  "type": "",\n  "vipps": {\n    "logo": "",\n    "subscriptionCancelUrl": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/paymentMethodSettings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "applePay": ["domains": []],
  "bcmc": ["enableBcmcMobile": false],
  "businessLineId": "",
  "cartesBancaires": ["siret": ""],
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "giroPay": ["supportEmail": ""],
  "googlePay": [
    "merchantId": "",
    "reuseMerchantId": false
  ],
  "klarna": [
    "autoCapture": false,
    "disputeEmail": "",
    "region": "",
    "supportEmail": ""
  ],
  "mealVoucher_FR": [
    "conecsId": "",
    "siret": "",
    "subTypes": []
  ],
  "paypal": [
    "directCapture": false,
    "payerId": "",
    "subject": ""
  ],
  "reference": "",
  "shopperInteraction": "",
  "sofort": [
    "currencyCode": "",
    "logo": ""
  ],
  "storeId": "",
  "swish": ["swishNumber": ""],
  "type": "",
  "vipps": [
    "logo": "",
    "subscriptionCancelUrl": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId");

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  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId" {:content-type :json
                                                                                                          :form-params {:countries []
                                                                                                                        :currencies []
                                                                                                                        :customRoutingFlags []
                                                                                                                        :enabled false
                                                                                                                        :shopperStatement {:doingBusinessAsName ""
                                                                                                                                           :type ""}
                                                                                                                        :storeIds []}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"),
    Content = new StringContent("{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"

	payload := strings.NewReader("{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\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/merchants/:merchantId/paymentMethodSettings/:paymentMethodId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 182

{
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "enabled": false,
  "shopperStatement": {
    "doingBusinessAsName": "",
    "type": ""
  },
  "storeIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\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  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")
  .header("content-type", "application/json")
  .body("{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\n}")
  .asString();

const data = JSON.stringify({
  countries: [],
  currencies: [],
  customRoutingFlags: [],
  enabled: false,
  shopperStatement: {
    doingBusinessAsName: '',
    type: ''
  },
  storeIds: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId',
  headers: {'content-type': 'application/json'},
  data: {
    countries: [],
    currencies: [],
    customRoutingFlags: [],
    enabled: false,
    shopperStatement: {doingBusinessAsName: '', type: ''},
    storeIds: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"countries":[],"currencies":[],"customRoutingFlags":[],"enabled":false,"shopperStatement":{"doingBusinessAsName":"","type":""},"storeIds":[]}'
};

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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "countries": [],\n  "currencies": [],\n  "customRoutingFlags": [],\n  "enabled": false,\n  "shopperStatement": {\n    "doingBusinessAsName": "",\n    "type": ""\n  },\n  "storeIds": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")
  .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/merchants/:merchantId/paymentMethodSettings/:paymentMethodId',
  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({
  countries: [],
  currencies: [],
  customRoutingFlags: [],
  enabled: false,
  shopperStatement: {doingBusinessAsName: '', type: ''},
  storeIds: []
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId',
  headers: {'content-type': 'application/json'},
  body: {
    countries: [],
    currencies: [],
    customRoutingFlags: [],
    enabled: false,
    shopperStatement: {doingBusinessAsName: '', type: ''},
    storeIds: []
  },
  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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  countries: [],
  currencies: [],
  customRoutingFlags: [],
  enabled: false,
  shopperStatement: {
    doingBusinessAsName: '',
    type: ''
  },
  storeIds: []
});

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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId',
  headers: {'content-type': 'application/json'},
  data: {
    countries: [],
    currencies: [],
    customRoutingFlags: [],
    enabled: false,
    shopperStatement: {doingBusinessAsName: '', type: ''},
    storeIds: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"countries":[],"currencies":[],"customRoutingFlags":[],"enabled":false,"shopperStatement":{"doingBusinessAsName":"","type":""},"storeIds":[]}'
};

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 = @{ @"countries": @[  ],
                              @"currencies": @[  ],
                              @"customRoutingFlags": @[  ],
                              @"enabled": @NO,
                              @"shopperStatement": @{ @"doingBusinessAsName": @"", @"type": @"" },
                              @"storeIds": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"]
                                                       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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId",
  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([
    'countries' => [
        
    ],
    'currencies' => [
        
    ],
    'customRoutingFlags' => [
        
    ],
    'enabled' => null,
    'shopperStatement' => [
        'doingBusinessAsName' => '',
        'type' => ''
    ],
    'storeIds' => [
        
    ]
  ]),
  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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId', [
  'body' => '{
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "enabled": false,
  "shopperStatement": {
    "doingBusinessAsName": "",
    "type": ""
  },
  "storeIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'countries' => [
    
  ],
  'currencies' => [
    
  ],
  'customRoutingFlags' => [
    
  ],
  'enabled' => null,
  'shopperStatement' => [
    'doingBusinessAsName' => '',
    'type' => ''
  ],
  'storeIds' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'countries' => [
    
  ],
  'currencies' => [
    
  ],
  'customRoutingFlags' => [
    
  ],
  'enabled' => null,
  'shopperStatement' => [
    'doingBusinessAsName' => '',
    'type' => ''
  ],
  'storeIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId');
$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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "enabled": false,
  "shopperStatement": {
    "doingBusinessAsName": "",
    "type": ""
  },
  "storeIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "enabled": false,
  "shopperStatement": {
    "doingBusinessAsName": "",
    "type": ""
  },
  "storeIds": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/merchants/:merchantId/paymentMethodSettings/:paymentMethodId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"

payload = {
    "countries": [],
    "currencies": [],
    "customRoutingFlags": [],
    "enabled": False,
    "shopperStatement": {
        "doingBusinessAsName": "",
        "type": ""
    },
    "storeIds": []
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId"

payload <- "{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")

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  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\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/merchants/:merchantId/paymentMethodSettings/:paymentMethodId') do |req|
  req.body = "{\n  \"countries\": [],\n  \"currencies\": [],\n  \"customRoutingFlags\": [],\n  \"enabled\": false,\n  \"shopperStatement\": {\n    \"doingBusinessAsName\": \"\",\n    \"type\": \"\"\n  },\n  \"storeIds\": []\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}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId";

    let payload = json!({
        "countries": (),
        "currencies": (),
        "customRoutingFlags": (),
        "enabled": false,
        "shopperStatement": json!({
            "doingBusinessAsName": "",
            "type": ""
        }),
        "storeIds": ()
    });

    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 '{
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "enabled": false,
  "shopperStatement": {
    "doingBusinessAsName": "",
    "type": ""
  },
  "storeIds": []
}' |  \
  http PATCH {{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "countries": [],\n  "currencies": [],\n  "customRoutingFlags": [],\n  "enabled": false,\n  "shopperStatement": {\n    "doingBusinessAsName": "",\n    "type": ""\n  },\n  "storeIds": []\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "countries": [],
  "currencies": [],
  "customRoutingFlags": [],
  "enabled": false,
  "shopperStatement": [
    "doingBusinessAsName": "",
    "type": ""
  ],
  "storeIds": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/paymentMethodSettings/:paymentMethodId")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/merchants/:merchantId/payoutSettings");

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  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/merchants/:merchantId/payoutSettings" {:content-type :json
                                                                                 :form-params {:enabled false
                                                                                               :enabledFromDate ""
                                                                                               :transferInstrumentId ""}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\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}}/merchants/:merchantId/payoutSettings"),
    Content = new StringContent("{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\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}}/merchants/:merchantId/payoutSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/payoutSettings"

	payload := strings.NewReader("{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\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/merchants/:merchantId/payoutSettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "enabled": false,
  "enabledFromDate": "",
  "transferInstrumentId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/merchants/:merchantId/payoutSettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/payoutSettings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\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  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/payoutSettings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/merchants/:merchantId/payoutSettings")
  .header("content-type", "application/json")
  .body("{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  enabled: false,
  enabledFromDate: '',
  transferInstrumentId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/merchants/:merchantId/payoutSettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/payoutSettings',
  headers: {'content-type': 'application/json'},
  data: {enabled: false, enabledFromDate: '', transferInstrumentId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"enabled":false,"enabledFromDate":"","transferInstrumentId":""}'
};

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}}/merchants/:merchantId/payoutSettings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "enabled": false,\n  "enabledFromDate": "",\n  "transferInstrumentId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/payoutSettings")
  .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/merchants/:merchantId/payoutSettings',
  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({enabled: false, enabledFromDate: '', transferInstrumentId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/merchants/:merchantId/payoutSettings',
  headers: {'content-type': 'application/json'},
  body: {enabled: false, enabledFromDate: '', transferInstrumentId: ''},
  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}}/merchants/:merchantId/payoutSettings');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  enabled: false,
  enabledFromDate: '',
  transferInstrumentId: ''
});

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}}/merchants/:merchantId/payoutSettings',
  headers: {'content-type': 'application/json'},
  data: {enabled: false, enabledFromDate: '', transferInstrumentId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"enabled":false,"enabledFromDate":"","transferInstrumentId":""}'
};

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 = @{ @"enabled": @NO,
                              @"enabledFromDate": @"",
                              @"transferInstrumentId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/payoutSettings"]
                                                       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}}/merchants/:merchantId/payoutSettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/payoutSettings",
  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([
    'enabled' => null,
    'enabledFromDate' => '',
    'transferInstrumentId' => ''
  ]),
  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}}/merchants/:merchantId/payoutSettings', [
  'body' => '{
  "enabled": false,
  "enabledFromDate": "",
  "transferInstrumentId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'enabled' => null,
  'enabledFromDate' => '',
  'transferInstrumentId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'enabled' => null,
  'enabledFromDate' => '',
  'transferInstrumentId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings');
$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}}/merchants/:merchantId/payoutSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "enabled": false,
  "enabledFromDate": "",
  "transferInstrumentId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/payoutSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "enabled": false,
  "enabledFromDate": "",
  "transferInstrumentId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/merchants/:merchantId/payoutSettings", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings"

payload = {
    "enabled": False,
    "enabledFromDate": "",
    "transferInstrumentId": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/payoutSettings"

payload <- "{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\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}}/merchants/:merchantId/payoutSettings")

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  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\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/merchants/:merchantId/payoutSettings') do |req|
  req.body = "{\n  \"enabled\": false,\n  \"enabledFromDate\": \"\",\n  \"transferInstrumentId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/payoutSettings";

    let payload = json!({
        "enabled": false,
        "enabledFromDate": "",
        "transferInstrumentId": ""
    });

    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 '{
  "enabled": false,
  "enabledFromDate": "",
  "transferInstrumentId": ""
}' |  \
  http POST {{baseUrl}}/merchants/:merchantId/payoutSettings \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "enabled": false,\n  "enabledFromDate": "",\n  "transferInstrumentId": ""\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/payoutSettings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "enabled": false,
  "enabledFromDate": "",
  "transferInstrumentId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/payoutSettings")! 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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

	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/merchants/:merchantId/payoutSettings/:payoutSettingsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"))
    .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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId';
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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/payoutSettings/:payoutSettingsId',
  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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');

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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId';
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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"]
                                                       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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId",
  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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/merchants/:merchantId/payoutSettings/:payoutSettingsId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")

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/merchants/:merchantId/payoutSettings/:payoutSettingsId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId";

    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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")! 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}}/merchants/:merchantId/payoutSettings");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/merchants/:merchantId/payoutSettings")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings"

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}}/merchants/:merchantId/payoutSettings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/payoutSettings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/payoutSettings"

	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/merchants/:merchantId/payoutSettings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/merchants/:merchantId/payoutSettings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/payoutSettings"))
    .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}}/merchants/:merchantId/payoutSettings")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/merchants/:merchantId/payoutSettings")
  .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}}/merchants/:merchantId/payoutSettings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/payoutSettings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings';
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}}/merchants/:merchantId/payoutSettings',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/payoutSettings")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/payoutSettings',
  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}}/merchants/:merchantId/payoutSettings'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/payoutSettings');

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}}/merchants/:merchantId/payoutSettings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings';
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}}/merchants/:merchantId/payoutSettings"]
                                                       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}}/merchants/:merchantId/payoutSettings" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/payoutSettings",
  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}}/merchants/:merchantId/payoutSettings');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/payoutSettings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/payoutSettings' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/merchants/:merchantId/payoutSettings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/payoutSettings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/payoutSettings")

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/merchants/:merchantId/payoutSettings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/payoutSettings";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/payoutSettings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/payoutSettings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/payoutSettings")! 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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

	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/merchants/:merchantId/payoutSettings/:payoutSettingsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"))
    .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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId';
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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/merchants/:merchantId/payoutSettings/:payoutSettingsId',
  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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');

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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId';
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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"]
                                                       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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId",
  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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/merchants/:merchantId/payoutSettings/:payoutSettingsId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")

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/merchants/:merchantId/payoutSettings/:payoutSettingsId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")! 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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId");

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  \"enabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId" {:content-type :json
                                                                                                    :form-params {:enabled false}})

require "http/client"

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"enabled\": false\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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"),
    Content = new StringContent("{\n  \"enabled\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"enabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

	payload := strings.NewReader("{\n  \"enabled\": false\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/merchants/:merchantId/payoutSettings/:payoutSettingsId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "enabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"enabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"enabled\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"enabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .header("content-type", "application/json")
  .body("{\n  \"enabled\": false\n}")
  .asString();

const data = JSON.stringify({
  enabled: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId',
  headers: {'content-type': 'application/json'},
  data: {enabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"enabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "enabled": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"enabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")
  .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/merchants/:merchantId/payoutSettings/:payoutSettingsId',
  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({enabled: false}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId',
  headers: {'content-type': 'application/json'},
  body: {enabled: false},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  enabled: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId',
  headers: {'content-type': 'application/json'},
  data: {enabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"enabled":false}'
};

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 = @{ @"enabled": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"]
                                                       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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"enabled\": false\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId",
  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([
    'enabled' => null
  ]),
  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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId', [
  'body' => '{
  "enabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'enabled' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'enabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId');
$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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "enabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "enabled": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"enabled\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/merchants/:merchantId/payoutSettings/:payoutSettingsId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

payload = { "enabled": False }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId"

payload <- "{\n  \"enabled\": false\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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")

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  \"enabled\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/merchants/:merchantId/payoutSettings/:payoutSettingsId') do |req|
  req.body = "{\n  \"enabled\": false\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}}/merchants/:merchantId/payoutSettings/:payoutSettingsId";

    let payload = json!({"enabled": false});

    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 '{
  "enabled": false
}' |  \
  http PATCH {{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "enabled": false\n}' \
  --output-document \
  - {{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["enabled": false] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/merchants/:merchantId/payoutSettings/:payoutSettingsId")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/companies/:companyId/androidApps");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/companies/:companyId/androidApps")