Account and Transaction API Specification - UKvv3.1.5

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account-access-consents");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/account-access-consents" {:headers {:sandbox-id ""}
                                                                    :content-type :json
                                                                    :form-params {:Data {:ExpirationDateTime ""
                                                                                         :Permissions []
                                                                                         :TransactionFromDateTime ""
                                                                                         :TransactionToDateTime ""}
                                                                                  :Risk {}}})

require "http/client"

url = "{{baseUrl}}/account-access-consents"
headers = HTTP::Headers{
  "sandbox-id" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\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}}/account-access-consents"),
    Headers =
    {
        { "sandbox-id", "" },
    },
    Content = new StringContent("{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\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}}/account-access-consents");
var request = new RestRequest("", Method.Post);
request.AddHeader("sandbox-id", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account-access-consents"

	payload := strings.NewReader("{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}")

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

	req.Header.Add("sandbox-id", "")
	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/account-access-consents HTTP/1.1
Sandbox-Id: 
Content-Type: application/json
Host: example.com
Content-Length: 153

{
  "Data": {
    "ExpirationDateTime": "",
    "Permissions": [],
    "TransactionFromDateTime": "",
    "TransactionToDateTime": ""
  },
  "Risk": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account-access-consents")
  .setHeader("sandbox-id", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account-access-consents"))
    .header("sandbox-id", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\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  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account-access-consents")
  .post(body)
  .addHeader("sandbox-id", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/account-access-consents")
  .header("sandbox-id", "")
  .header("content-type", "application/json")
  .body("{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}")
  .asString();

const data = JSON.stringify({
  Data: {
    ExpirationDateTime: '',
    Permissions: [],
    TransactionFromDateTime: '',
    TransactionToDateTime: ''
  },
  Risk: {}
});

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

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

xhr.open('POST', '{{baseUrl}}/account-access-consents');
xhr.setRequestHeader('sandbox-id', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account-access-consents',
  headers: {'sandbox-id': '', 'content-type': 'application/json'},
  data: {
    Data: {
      ExpirationDateTime: '',
      Permissions: [],
      TransactionFromDateTime: '',
      TransactionToDateTime: ''
    },
    Risk: {}
  }
};

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

const url = '{{baseUrl}}/account-access-consents';
const options = {
  method: 'POST',
  headers: {'sandbox-id': '', 'content-type': 'application/json'},
  body: '{"Data":{"ExpirationDateTime":"","Permissions":[],"TransactionFromDateTime":"","TransactionToDateTime":""},"Risk":{}}'
};

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}}/account-access-consents',
  method: 'POST',
  headers: {
    'sandbox-id': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Data": {\n    "ExpirationDateTime": "",\n    "Permissions": [],\n    "TransactionFromDateTime": "",\n    "TransactionToDateTime": ""\n  },\n  "Risk": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account-access-consents")
  .post(body)
  .addHeader("sandbox-id", "")
  .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/account-access-consents',
  headers: {
    'sandbox-id': '',
    '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({
  Data: {
    ExpirationDateTime: '',
    Permissions: [],
    TransactionFromDateTime: '',
    TransactionToDateTime: ''
  },
  Risk: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account-access-consents',
  headers: {'sandbox-id': '', 'content-type': 'application/json'},
  body: {
    Data: {
      ExpirationDateTime: '',
      Permissions: [],
      TransactionFromDateTime: '',
      TransactionToDateTime: ''
    },
    Risk: {}
  },
  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}}/account-access-consents');

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

req.type('json');
req.send({
  Data: {
    ExpirationDateTime: '',
    Permissions: [],
    TransactionFromDateTime: '',
    TransactionToDateTime: ''
  },
  Risk: {}
});

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}}/account-access-consents',
  headers: {'sandbox-id': '', 'content-type': 'application/json'},
  data: {
    Data: {
      ExpirationDateTime: '',
      Permissions: [],
      TransactionFromDateTime: '',
      TransactionToDateTime: ''
    },
    Risk: {}
  }
};

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

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

const url = '{{baseUrl}}/account-access-consents';
const options = {
  method: 'POST',
  headers: {'sandbox-id': '', 'content-type': 'application/json'},
  body: '{"Data":{"ExpirationDateTime":"","Permissions":[],"TransactionFromDateTime":"","TransactionToDateTime":""},"Risk":{}}'
};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Data": @{ @"ExpirationDateTime": @"", @"Permissions": @[  ], @"TransactionFromDateTime": @"", @"TransactionToDateTime": @"" },
                              @"Risk": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account-access-consents"]
                                                       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}}/account-access-consents" in
let headers = Header.add_list (Header.init ()) [
  ("sandbox-id", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}" in

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

 "{{baseUrl}}/account-access-consents",
  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([
    'Data' => [
        'ExpirationDateTime' => '',
        'Permissions' => [
                
        ],
        'TransactionFromDateTime' => '',
        'TransactionToDateTime' => ''
    ],
    'Risk' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/account-access-consents', [
  'body' => '{
  "Data": {
    "ExpirationDateTime": "",
    "Permissions": [],
    "TransactionFromDateTime": "",
    "TransactionToDateTime": ""
  },
  "Risk": {}
}',
  'headers' => [
    'content-type' => 'application/json',
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account-access-consents');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Data' => [
    'ExpirationDateTime' => '',
    'Permissions' => [
        
    ],
    'TransactionFromDateTime' => '',
    'TransactionToDateTime' => ''
  ],
  'Risk' => [
    
  ]
]));

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

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

append(json_encode([
  'Data' => [
    'ExpirationDateTime' => '',
    'Permissions' => [
        
    ],
    'TransactionFromDateTime' => '',
    'TransactionToDateTime' => ''
  ],
  'Risk' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account-access-consents');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account-access-consents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Data": {
    "ExpirationDateTime": "",
    "Permissions": [],
    "TransactionFromDateTime": "",
    "TransactionToDateTime": ""
  },
  "Risk": {}
}'

$headers=@{}
$headers.Add("sandbox-id", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account-access-consents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Data": {
    "ExpirationDateTime": "",
    "Permissions": [],
    "TransactionFromDateTime": "",
    "TransactionToDateTime": ""
  },
  "Risk": {}
}'

import http.client

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

payload = "{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}"

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

conn.request("POST", "/baseUrl/account-access-consents", payload, headers)

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

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

import requests

url = "{{baseUrl}}/account-access-consents"

payload = {
    "Data": {
        "ExpirationDateTime": "",
        "Permissions": [],
        "TransactionFromDateTime": "",
        "TransactionToDateTime": ""
    },
    "Risk": {}
}
headers = {
    "sandbox-id": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account-access-consents"

payload <- "{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account-access-consents")

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

request = Net::HTTP::Post.new(url)
request["sandbox-id"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\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/account-access-consents') do |req|
  req.headers['sandbox-id'] = ''
  req.body = "{\n  \"Data\": {\n    \"ExpirationDateTime\": \"\",\n    \"Permissions\": [],\n    \"TransactionFromDateTime\": \"\",\n    \"TransactionToDateTime\": \"\"\n  },\n  \"Risk\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Data": json!({
            "ExpirationDateTime": "",
            "Permissions": (),
            "TransactionFromDateTime": "",
            "TransactionToDateTime": ""
        }),
        "Risk": json!({})
    });

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

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

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

    dbg!(results);
}

echo '{
  "Data": {
    "ExpirationDateTime": "",
    "Permissions": [],
    "TransactionFromDateTime": "",
    "TransactionToDateTime": ""
  },
  "Risk": {}
}' |  \
  http POST {{baseUrl}}/account-access-consents \
  content-type:application/json \
  sandbox-id:''

wget --quiet \
  --method POST \
  --header 'sandbox-id: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Data": {\n    "ExpirationDateTime": "",\n    "Permissions": [],\n    "TransactionFromDateTime": "",\n    "TransactionToDateTime": ""\n  },\n  "Risk": {}\n}' \
  --output-document \
  - {{baseUrl}}/account-access-consents

import Foundation

let headers = [
  "sandbox-id": "",
  "content-type": "application/json"
]
let parameters = [
  "Data": [
    "ExpirationDateTime": "",
    "Permissions": [],
    "TransactionFromDateTime": "",
    "TransactionToDateTime": ""
  ],
  "Risk": []
] as [String : Any]

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/account-access-consents/:consentId" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/account-access-consents/:consentId"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account-access-consents/:consentId"),
    Headers =
    {
        { "sandbox-id", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account-access-consents/:consentId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("sandbox-id", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account-access-consents/:consentId"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

DELETE /baseUrl/account-access-consents/:consentId HTTP/1.1
Sandbox-Id: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account-access-consents/:consentId")
  .setHeader("sandbox-id", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account-access-consents/:consentId"))
    .header("sandbox-id", "")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account-access-consents/:consentId")
  .delete(null)
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/account-access-consents/:consentId")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/account-access-consents/:consentId');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account-access-consents/:consentId',
  headers: {'sandbox-id': ''}
};

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

const url = '{{baseUrl}}/account-access-consents/:consentId';
const options = {method: 'DELETE', headers: {'sandbox-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}}/account-access-consents/:consentId',
  method: 'DELETE',
  headers: {
    'sandbox-id': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account-access-consents/:consentId")
  .delete(null)
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account-access-consents/:consentId',
  headers: {
    'sandbox-id': ''
  }
};

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}}/account-access-consents/:consentId',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account-access-consents/:consentId');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account-access-consents/:consentId',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/account-access-consents/:consentId';
const options = {method: 'DELETE', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account-access-consents/:consentId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account-access-consents/:consentId" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/account-access-consents/:consentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/account-access-consents/:consentId', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account-access-consents/:consentId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/account-access-consents/:consentId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account-access-consents/:consentId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account-access-consents/:consentId' -Method DELETE -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("DELETE", "/baseUrl/account-access-consents/:consentId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/account-access-consents/:consentId"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account-access-consents/:consentId"

response <- VERB("DELETE", url, add_headers('sandbox-id' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account-access-consents/:consentId")

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

request = Net::HTTP::Delete.new(url)
request["sandbox-id"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/account-access-consents/:consentId') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account-access-consents/:consentId";

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/account-access-consents/:consentId \
  sandbox-id:''

wget --quiet \
  --method DELETE \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/account-access-consents/:consentId

import Foundation

let headers = ["sandbox-id": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account-access-consents/:consentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account-access-consents/:consentId");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/account-access-consents/:consentId" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/account-access-consents/:consentId"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/account-access-consents/:consentId");
var request = new RestRequest("", Method.Get);
request.AddHeader("sandbox-id", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account-access-consents/:consentId"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/account-access-consents/:consentId HTTP/1.1
Sandbox-Id: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account-access-consents/:consentId")
  .setHeader("sandbox-id", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account-access-consents/:consentId"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account-access-consents/:consentId")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/account-access-consents/:consentId")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/account-access-consents/:consentId');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account-access-consents/:consentId',
  headers: {'sandbox-id': ''}
};

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

const url = '{{baseUrl}}/account-access-consents/:consentId';
const options = {method: 'GET', headers: {'sandbox-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}}/account-access-consents/:consentId',
  method: 'GET',
  headers: {
    'sandbox-id': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account-access-consents/:consentId")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account-access-consents/:consentId',
  headers: {
    'sandbox-id': ''
  }
};

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}}/account-access-consents/:consentId',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account-access-consents/:consentId');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account-access-consents/:consentId',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/account-access-consents/:consentId';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account-access-consents/:consentId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account-access-consents/:consentId" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/account-access-consents/:consentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/account-access-consents/:consentId', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account-access-consents/:consentId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/account-access-consents/:consentId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account-access-consents/:consentId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account-access-consents/:consentId' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/account-access-consents/:consentId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/account-access-consents/:consentId"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account-access-consents/:consentId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account-access-consents/:consentId")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/account-access-consents/:consentId') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account-access-consents/:consentId";

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/account-access-consents/:consentId \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/account-access-consents/:consentId

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/:accountId" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts/:accountId HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts/:accountId');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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}}/accounts/:accountId',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId');

req.headers({
  'sandbox-id': ''
});

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

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

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

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

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

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

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

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/accounts/:accountId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accounts/:accountId', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accounts/:accountId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/accounts/:accountId') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/accounts"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

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

package main

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

func main() {

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

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

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

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}}/accounts',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'sandbox-id': ''
});

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

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

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

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

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

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

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

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/accounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accounts', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accounts');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

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

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

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

import requests

url = "{{baseUrl}}/accounts"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/accounts') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/balances");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/:accountId/balances" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/balances"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/balances"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts/:accountId/balances HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/balances"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/balances")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/balances")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/balances');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/balances',
  headers: {'sandbox-id': ''}
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/balances")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/balances',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/balances',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/balances');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/balances',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/balances';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/balances" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/accounts/:accountId/balances",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accounts/:accountId/balances', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accounts/:accountId/balances');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/balances' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/balances' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/balances", headers=headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/balances"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/balances"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/balances")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/accounts/:accountId/balances') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/balances \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/balances

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/beneficiaries");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/:accountId/beneficiaries" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/beneficiaries"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/beneficiaries"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts/:accountId/beneficiaries HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/beneficiaries"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/beneficiaries")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/beneficiaries")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/beneficiaries');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/beneficiaries',
  headers: {'sandbox-id': ''}
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/beneficiaries")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/beneficiaries',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/beneficiaries',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/beneficiaries');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/beneficiaries',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/beneficiaries';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/beneficiaries" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/accounts/:accountId/beneficiaries",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accounts/:accountId/beneficiaries', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accounts/:accountId/beneficiaries');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/beneficiaries' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/beneficiaries' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/beneficiaries", headers=headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/beneficiaries"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/beneficiaries"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/beneficiaries")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/accounts/:accountId/beneficiaries') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/beneficiaries \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/beneficiaries

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/parties");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/:accountId/parties" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/parties"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/parties"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts/:accountId/parties HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/parties"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/parties")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/parties")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/parties');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/parties',
  headers: {'sandbox-id': ''}
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/parties")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/parties',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/parties',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/parties');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/parties',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/parties';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/parties" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/accounts/:accountId/parties",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accounts/:accountId/parties', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accounts/:accountId/parties');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/parties' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/parties' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/parties", headers=headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/parties"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/parties"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/parties")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/accounts/:accountId/parties') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/parties \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/parties

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/party" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/party"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/party");
var request = new RestRequest("", Method.Get);
request.AddHeader("sandbox-id", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/party HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/party")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/party")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/party');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/party',
  headers: {'sandbox-id': ''}
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/party")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

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

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}}/party',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/party',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/party';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/party" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/party",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/party', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/party');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/party' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/party' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

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

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

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

import requests

url = "{{baseUrl}}/party"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/party') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/party \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/party

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/party");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/:accountId/party" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/party"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/party"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts/:accountId/party HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/party"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/party")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/party")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/party');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/party',
  headers: {'sandbox-id': ''}
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/party")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/party',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/party',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/party');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/party',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/party';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/party" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/accounts/:accountId/party",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accounts/:accountId/party', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accounts/:accountId/party');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/party' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/party' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/party", headers=headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/party"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/party"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/party")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/accounts/:accountId/party') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/party \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/party

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"sandboxId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/sandbox" {:content-type :json
                                                    :form-params {:sandboxId ""}})

require "http/client"

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

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"sandboxId\": \"\"\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/sandbox HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "sandboxId": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/sandbox")
  .header("content-type", "application/json")
  .body("{\n  \"sandboxId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  sandboxId: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sandbox',
  headers: {'content-type': 'application/json'},
  data: {sandboxId: ''}
};

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

const url = '{{baseUrl}}/sandbox';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"sandboxId":""}'
};

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}}/sandbox',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "sandboxId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"sandboxId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/sandbox")
  .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/sandbox',
  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({sandboxId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sandbox',
  headers: {'content-type': 'application/json'},
  body: {sandboxId: ''},
  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}}/sandbox');

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

req.type('json');
req.send({
  sandboxId: ''
});

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}}/sandbox',
  headers: {'content-type': 'application/json'},
  data: {sandboxId: ''}
};

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

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

const url = '{{baseUrl}}/sandbox';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"sandboxId":""}'
};

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 = @{ @"sandboxId": @"" };

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

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

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

 "{{baseUrl}}/sandbox",
  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([
    'sandboxId' => ''
  ]),
  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}}/sandbox', [
  'body' => '{
  "sandboxId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'sandboxId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/sandbox');
$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}}/sandbox' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "sandboxId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/sandbox' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "sandboxId": ""
}'

import http.client

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

payload = "{\n  \"sandboxId\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/sandbox"

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

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

print(response.json())

library(httr)

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

payload <- "{\n  \"sandboxId\": \"\"\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}}/sandbox")

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  \"sandboxId\": \"\"\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/sandbox') do |req|
  req.body = "{\n  \"sandboxId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"sandboxId": ""});

    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 '{
  "sandboxId": ""
}' |  \
  http POST {{baseUrl}}/sandbox \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "sandboxId": ""\n}' \
  --output-document \
  - {{baseUrl}}/sandbox

import Foundation

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/sandbox/:sandboxId")

require "http/client"

url = "{{baseUrl}}/sandbox/:sandboxId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/sandbox/:sandboxId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/sandbox/:sandboxId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/sandbox/:sandboxId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/sandbox/:sandboxId');

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}}/sandbox/:sandboxId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/sandbox/:sandboxId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/sandbox/:sandboxId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/sandbox/:sandboxId")

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

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

import requests

url = "{{baseUrl}}/sandbox/:sandboxId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sandbox/:sandboxId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sandbox/:sandboxId")

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/sandbox/:sandboxId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/sandbox/:sandboxId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/sandbox/:sandboxId

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/sandbox/:sandboxId")

require "http/client"

url = "{{baseUrl}}/sandbox/:sandboxId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/sandbox/:sandboxId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/sandbox/:sandboxId');

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}}/sandbox/:sandboxId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/sandbox/:sandboxId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/sandbox/:sandboxId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/sandbox/:sandboxId")

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

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

import requests

url = "{{baseUrl}}/sandbox/:sandboxId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sandbox/:sandboxId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sandbox/:sandboxId")

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/sandbox/:sandboxId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/sandbox/:sandboxId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/sandbox/:sandboxId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sandbox");

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  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/sandbox" {:content-type :json
                                                   :form-params {:sandboxId ""
                                                                 :users [{:accounts [{:beneficiaries [{:name ""}]
                                                                                      :info {:accountSubType ""
                                                                                             :accountType ""
                                                                                             :alias ""
                                                                                             :availableBalance ""
                                                                                             :currency ""
                                                                                             :description ""
                                                                                             :iban ""
                                                                                             :ledgerBalance ""
                                                                                             :openingDate ""
                                                                                             :overdraftLimit ""}
                                                                                      :party {:id ""
                                                                                              :name ""}
                                                                                      :scheduledPayments [{:amount ""
                                                                                                           :description ""
                                                                                                           :executionDate ""
                                                                                                           :senderReference ""}]
                                                                                      :standingOrders [{:amount ""
                                                                                                        :description ""
                                                                                                        :finalPaymentDate ""
                                                                                                        :firstPaymentDate ""
                                                                                                        :frequency ""
                                                                                                        :lastPaymentDate ""
                                                                                                        :nextPaymentDate ""
                                                                                                        :status ""}]
                                                                                      :statements [{:month 0
                                                                                                    :number ""
                                                                                                    :year 0}]
                                                                                      :transactions [{:accountingBalance ""
                                                                                                      :amount ""
                                                                                                      :bookingDateTime ""
                                                                                                      :creditDebit ""
                                                                                                      :currency ""
                                                                                                      :description ""
                                                                                                      :reference ""
                                                                                                      :relatedAccount ""
                                                                                                      :relatedName ""
                                                                                                      :transactionCode ""
                                                                                                      :valueDateTime ""}]}]
                                                                          :cards [{:info {:availableBalance ""
                                                                                          :creditLimit ""
                                                                                          :description ""
                                                                                          :expiration ""
                                                                                          :holderName ""
                                                                                          :ledgerBalance ""
                                                                                          :number ""
                                                                                          :subType ""
                                                                                          :type ""}
                                                                                   :party {}
                                                                                   :statements [{}]
                                                                                   :transactions [{}]}]
                                                                          :retryCacheEntries [{:cacheKey ""
                                                                                               :count 0
                                                                                               :expirationTimestamp ""}]
                                                                          :userId ""}]}})

require "http/client"

url = "{{baseUrl}}/sandbox"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/sandbox"),
    Content = new StringContent("{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/sandbox");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

PUT /baseUrl/sandbox HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2382

{
  "sandboxId": "",
  "users": [
    {
      "accounts": [
        {
          "beneficiaries": [
            {
              "name": ""
            }
          ],
          "info": {
            "accountSubType": "",
            "accountType": "",
            "alias": "",
            "availableBalance": "",
            "currency": "",
            "description": "",
            "iban": "",
            "ledgerBalance": "",
            "openingDate": "",
            "overdraftLimit": ""
          },
          "party": {
            "id": "",
            "name": ""
          },
          "scheduledPayments": [
            {
              "amount": "",
              "description": "",
              "executionDate": "",
              "senderReference": ""
            }
          ],
          "standingOrders": [
            {
              "amount": "",
              "description": "",
              "finalPaymentDate": "",
              "firstPaymentDate": "",
              "frequency": "",
              "lastPaymentDate": "",
              "nextPaymentDate": "",
              "status": ""
            }
          ],
          "statements": [
            {
              "month": 0,
              "number": "",
              "year": 0
            }
          ],
          "transactions": [
            {
              "accountingBalance": "",
              "amount": "",
              "bookingDateTime": "",
              "creditDebit": "",
              "currency": "",
              "description": "",
              "reference": "",
              "relatedAccount": "",
              "relatedName": "",
              "transactionCode": "",
              "valueDateTime": ""
            }
          ]
        }
      ],
      "cards": [
        {
          "info": {
            "availableBalance": "",
            "creditLimit": "",
            "description": "",
            "expiration": "",
            "holderName": "",
            "ledgerBalance": "",
            "number": "",
            "subType": "",
            "type": ""
          },
          "party": {},
          "statements": [
            {}
          ],
          "transactions": [
            {}
          ]
        }
      ],
      "retryCacheEntries": [
        {
          "cacheKey": "",
          "count": 0,
          "expirationTimestamp": ""
        }
      ],
      "userId": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/sandbox")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sandbox"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/sandbox")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/sandbox")
  .header("content-type", "application/json")
  .body("{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  sandboxId: '',
  users: [
    {
      accounts: [
        {
          beneficiaries: [
            {
              name: ''
            }
          ],
          info: {
            accountSubType: '',
            accountType: '',
            alias: '',
            availableBalance: '',
            currency: '',
            description: '',
            iban: '',
            ledgerBalance: '',
            openingDate: '',
            overdraftLimit: ''
          },
          party: {
            id: '',
            name: ''
          },
          scheduledPayments: [
            {
              amount: '',
              description: '',
              executionDate: '',
              senderReference: ''
            }
          ],
          standingOrders: [
            {
              amount: '',
              description: '',
              finalPaymentDate: '',
              firstPaymentDate: '',
              frequency: '',
              lastPaymentDate: '',
              nextPaymentDate: '',
              status: ''
            }
          ],
          statements: [
            {
              month: 0,
              number: '',
              year: 0
            }
          ],
          transactions: [
            {
              accountingBalance: '',
              amount: '',
              bookingDateTime: '',
              creditDebit: '',
              currency: '',
              description: '',
              reference: '',
              relatedAccount: '',
              relatedName: '',
              transactionCode: '',
              valueDateTime: ''
            }
          ]
        }
      ],
      cards: [
        {
          info: {
            availableBalance: '',
            creditLimit: '',
            description: '',
            expiration: '',
            holderName: '',
            ledgerBalance: '',
            number: '',
            subType: '',
            type: ''
          },
          party: {},
          statements: [
            {}
          ],
          transactions: [
            {}
          ]
        }
      ],
      retryCacheEntries: [
        {
          cacheKey: '',
          count: 0,
          expirationTimestamp: ''
        }
      ],
      userId: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/sandbox',
  headers: {'content-type': 'application/json'},
  data: {
    sandboxId: '',
    users: [
      {
        accounts: [
          {
            beneficiaries: [{name: ''}],
            info: {
              accountSubType: '',
              accountType: '',
              alias: '',
              availableBalance: '',
              currency: '',
              description: '',
              iban: '',
              ledgerBalance: '',
              openingDate: '',
              overdraftLimit: ''
            },
            party: {id: '', name: ''},
            scheduledPayments: [{amount: '', description: '', executionDate: '', senderReference: ''}],
            standingOrders: [
              {
                amount: '',
                description: '',
                finalPaymentDate: '',
                firstPaymentDate: '',
                frequency: '',
                lastPaymentDate: '',
                nextPaymentDate: '',
                status: ''
              }
            ],
            statements: [{month: 0, number: '', year: 0}],
            transactions: [
              {
                accountingBalance: '',
                amount: '',
                bookingDateTime: '',
                creditDebit: '',
                currency: '',
                description: '',
                reference: '',
                relatedAccount: '',
                relatedName: '',
                transactionCode: '',
                valueDateTime: ''
              }
            ]
          }
        ],
        cards: [
          {
            info: {
              availableBalance: '',
              creditLimit: '',
              description: '',
              expiration: '',
              holderName: '',
              ledgerBalance: '',
              number: '',
              subType: '',
              type: ''
            },
            party: {},
            statements: [{}],
            transactions: [{}]
          }
        ],
        retryCacheEntries: [{cacheKey: '', count: 0, expirationTimestamp: ''}],
        userId: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/sandbox';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"sandboxId":"","users":[{"accounts":[{"beneficiaries":[{"name":""}],"info":{"accountSubType":"","accountType":"","alias":"","availableBalance":"","currency":"","description":"","iban":"","ledgerBalance":"","openingDate":"","overdraftLimit":""},"party":{"id":"","name":""},"scheduledPayments":[{"amount":"","description":"","executionDate":"","senderReference":""}],"standingOrders":[{"amount":"","description":"","finalPaymentDate":"","firstPaymentDate":"","frequency":"","lastPaymentDate":"","nextPaymentDate":"","status":""}],"statements":[{"month":0,"number":"","year":0}],"transactions":[{"accountingBalance":"","amount":"","bookingDateTime":"","creditDebit":"","currency":"","description":"","reference":"","relatedAccount":"","relatedName":"","transactionCode":"","valueDateTime":""}]}],"cards":[{"info":{"availableBalance":"","creditLimit":"","description":"","expiration":"","holderName":"","ledgerBalance":"","number":"","subType":"","type":""},"party":{},"statements":[{}],"transactions":[{}]}],"retryCacheEntries":[{"cacheKey":"","count":0,"expirationTimestamp":""}],"userId":""}]}'
};

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}}/sandbox',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "sandboxId": "",\n  "users": [\n    {\n      "accounts": [\n        {\n          "beneficiaries": [\n            {\n              "name": ""\n            }\n          ],\n          "info": {\n            "accountSubType": "",\n            "accountType": "",\n            "alias": "",\n            "availableBalance": "",\n            "currency": "",\n            "description": "",\n            "iban": "",\n            "ledgerBalance": "",\n            "openingDate": "",\n            "overdraftLimit": ""\n          },\n          "party": {\n            "id": "",\n            "name": ""\n          },\n          "scheduledPayments": [\n            {\n              "amount": "",\n              "description": "",\n              "executionDate": "",\n              "senderReference": ""\n            }\n          ],\n          "standingOrders": [\n            {\n              "amount": "",\n              "description": "",\n              "finalPaymentDate": "",\n              "firstPaymentDate": "",\n              "frequency": "",\n              "lastPaymentDate": "",\n              "nextPaymentDate": "",\n              "status": ""\n            }\n          ],\n          "statements": [\n            {\n              "month": 0,\n              "number": "",\n              "year": 0\n            }\n          ],\n          "transactions": [\n            {\n              "accountingBalance": "",\n              "amount": "",\n              "bookingDateTime": "",\n              "creditDebit": "",\n              "currency": "",\n              "description": "",\n              "reference": "",\n              "relatedAccount": "",\n              "relatedName": "",\n              "transactionCode": "",\n              "valueDateTime": ""\n            }\n          ]\n        }\n      ],\n      "cards": [\n        {\n          "info": {\n            "availableBalance": "",\n            "creditLimit": "",\n            "description": "",\n            "expiration": "",\n            "holderName": "",\n            "ledgerBalance": "",\n            "number": "",\n            "subType": "",\n            "type": ""\n          },\n          "party": {},\n          "statements": [\n            {}\n          ],\n          "transactions": [\n            {}\n          ]\n        }\n      ],\n      "retryCacheEntries": [\n        {\n          "cacheKey": "",\n          "count": 0,\n          "expirationTimestamp": ""\n        }\n      ],\n      "userId": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/sandbox")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/sandbox',
  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({
  sandboxId: '',
  users: [
    {
      accounts: [
        {
          beneficiaries: [{name: ''}],
          info: {
            accountSubType: '',
            accountType: '',
            alias: '',
            availableBalance: '',
            currency: '',
            description: '',
            iban: '',
            ledgerBalance: '',
            openingDate: '',
            overdraftLimit: ''
          },
          party: {id: '', name: ''},
          scheduledPayments: [{amount: '', description: '', executionDate: '', senderReference: ''}],
          standingOrders: [
            {
              amount: '',
              description: '',
              finalPaymentDate: '',
              firstPaymentDate: '',
              frequency: '',
              lastPaymentDate: '',
              nextPaymentDate: '',
              status: ''
            }
          ],
          statements: [{month: 0, number: '', year: 0}],
          transactions: [
            {
              accountingBalance: '',
              amount: '',
              bookingDateTime: '',
              creditDebit: '',
              currency: '',
              description: '',
              reference: '',
              relatedAccount: '',
              relatedName: '',
              transactionCode: '',
              valueDateTime: ''
            }
          ]
        }
      ],
      cards: [
        {
          info: {
            availableBalance: '',
            creditLimit: '',
            description: '',
            expiration: '',
            holderName: '',
            ledgerBalance: '',
            number: '',
            subType: '',
            type: ''
          },
          party: {},
          statements: [{}],
          transactions: [{}]
        }
      ],
      retryCacheEntries: [{cacheKey: '', count: 0, expirationTimestamp: ''}],
      userId: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/sandbox',
  headers: {'content-type': 'application/json'},
  body: {
    sandboxId: '',
    users: [
      {
        accounts: [
          {
            beneficiaries: [{name: ''}],
            info: {
              accountSubType: '',
              accountType: '',
              alias: '',
              availableBalance: '',
              currency: '',
              description: '',
              iban: '',
              ledgerBalance: '',
              openingDate: '',
              overdraftLimit: ''
            },
            party: {id: '', name: ''},
            scheduledPayments: [{amount: '', description: '', executionDate: '', senderReference: ''}],
            standingOrders: [
              {
                amount: '',
                description: '',
                finalPaymentDate: '',
                firstPaymentDate: '',
                frequency: '',
                lastPaymentDate: '',
                nextPaymentDate: '',
                status: ''
              }
            ],
            statements: [{month: 0, number: '', year: 0}],
            transactions: [
              {
                accountingBalance: '',
                amount: '',
                bookingDateTime: '',
                creditDebit: '',
                currency: '',
                description: '',
                reference: '',
                relatedAccount: '',
                relatedName: '',
                transactionCode: '',
                valueDateTime: ''
              }
            ]
          }
        ],
        cards: [
          {
            info: {
              availableBalance: '',
              creditLimit: '',
              description: '',
              expiration: '',
              holderName: '',
              ledgerBalance: '',
              number: '',
              subType: '',
              type: ''
            },
            party: {},
            statements: [{}],
            transactions: [{}]
          }
        ],
        retryCacheEntries: [{cacheKey: '', count: 0, expirationTimestamp: ''}],
        userId: ''
      }
    ]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/sandbox');

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

req.type('json');
req.send({
  sandboxId: '',
  users: [
    {
      accounts: [
        {
          beneficiaries: [
            {
              name: ''
            }
          ],
          info: {
            accountSubType: '',
            accountType: '',
            alias: '',
            availableBalance: '',
            currency: '',
            description: '',
            iban: '',
            ledgerBalance: '',
            openingDate: '',
            overdraftLimit: ''
          },
          party: {
            id: '',
            name: ''
          },
          scheduledPayments: [
            {
              amount: '',
              description: '',
              executionDate: '',
              senderReference: ''
            }
          ],
          standingOrders: [
            {
              amount: '',
              description: '',
              finalPaymentDate: '',
              firstPaymentDate: '',
              frequency: '',
              lastPaymentDate: '',
              nextPaymentDate: '',
              status: ''
            }
          ],
          statements: [
            {
              month: 0,
              number: '',
              year: 0
            }
          ],
          transactions: [
            {
              accountingBalance: '',
              amount: '',
              bookingDateTime: '',
              creditDebit: '',
              currency: '',
              description: '',
              reference: '',
              relatedAccount: '',
              relatedName: '',
              transactionCode: '',
              valueDateTime: ''
            }
          ]
        }
      ],
      cards: [
        {
          info: {
            availableBalance: '',
            creditLimit: '',
            description: '',
            expiration: '',
            holderName: '',
            ledgerBalance: '',
            number: '',
            subType: '',
            type: ''
          },
          party: {},
          statements: [
            {}
          ],
          transactions: [
            {}
          ]
        }
      ],
      retryCacheEntries: [
        {
          cacheKey: '',
          count: 0,
          expirationTimestamp: ''
        }
      ],
      userId: ''
    }
  ]
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/sandbox',
  headers: {'content-type': 'application/json'},
  data: {
    sandboxId: '',
    users: [
      {
        accounts: [
          {
            beneficiaries: [{name: ''}],
            info: {
              accountSubType: '',
              accountType: '',
              alias: '',
              availableBalance: '',
              currency: '',
              description: '',
              iban: '',
              ledgerBalance: '',
              openingDate: '',
              overdraftLimit: ''
            },
            party: {id: '', name: ''},
            scheduledPayments: [{amount: '', description: '', executionDate: '', senderReference: ''}],
            standingOrders: [
              {
                amount: '',
                description: '',
                finalPaymentDate: '',
                firstPaymentDate: '',
                frequency: '',
                lastPaymentDate: '',
                nextPaymentDate: '',
                status: ''
              }
            ],
            statements: [{month: 0, number: '', year: 0}],
            transactions: [
              {
                accountingBalance: '',
                amount: '',
                bookingDateTime: '',
                creditDebit: '',
                currency: '',
                description: '',
                reference: '',
                relatedAccount: '',
                relatedName: '',
                transactionCode: '',
                valueDateTime: ''
              }
            ]
          }
        ],
        cards: [
          {
            info: {
              availableBalance: '',
              creditLimit: '',
              description: '',
              expiration: '',
              holderName: '',
              ledgerBalance: '',
              number: '',
              subType: '',
              type: ''
            },
            party: {},
            statements: [{}],
            transactions: [{}]
          }
        ],
        retryCacheEntries: [{cacheKey: '', count: 0, expirationTimestamp: ''}],
        userId: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/sandbox';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"sandboxId":"","users":[{"accounts":[{"beneficiaries":[{"name":""}],"info":{"accountSubType":"","accountType":"","alias":"","availableBalance":"","currency":"","description":"","iban":"","ledgerBalance":"","openingDate":"","overdraftLimit":""},"party":{"id":"","name":""},"scheduledPayments":[{"amount":"","description":"","executionDate":"","senderReference":""}],"standingOrders":[{"amount":"","description":"","finalPaymentDate":"","firstPaymentDate":"","frequency":"","lastPaymentDate":"","nextPaymentDate":"","status":""}],"statements":[{"month":0,"number":"","year":0}],"transactions":[{"accountingBalance":"","amount":"","bookingDateTime":"","creditDebit":"","currency":"","description":"","reference":"","relatedAccount":"","relatedName":"","transactionCode":"","valueDateTime":""}]}],"cards":[{"info":{"availableBalance":"","creditLimit":"","description":"","expiration":"","holderName":"","ledgerBalance":"","number":"","subType":"","type":""},"party":{},"statements":[{}],"transactions":[{}]}],"retryCacheEntries":[{"cacheKey":"","count":0,"expirationTimestamp":""}],"userId":""}]}'
};

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 = @{ @"sandboxId": @"",
                              @"users": @[ @{ @"accounts": @[ @{ @"beneficiaries": @[ @{ @"name": @"" } ], @"info": @{ @"accountSubType": @"", @"accountType": @"", @"alias": @"", @"availableBalance": @"", @"currency": @"", @"description": @"", @"iban": @"", @"ledgerBalance": @"", @"openingDate": @"", @"overdraftLimit": @"" }, @"party": @{ @"id": @"", @"name": @"" }, @"scheduledPayments": @[ @{ @"amount": @"", @"description": @"", @"executionDate": @"", @"senderReference": @"" } ], @"standingOrders": @[ @{ @"amount": @"", @"description": @"", @"finalPaymentDate": @"", @"firstPaymentDate": @"", @"frequency": @"", @"lastPaymentDate": @"", @"nextPaymentDate": @"", @"status": @"" } ], @"statements": @[ @{ @"month": @0, @"number": @"", @"year": @0 } ], @"transactions": @[ @{ @"accountingBalance": @"", @"amount": @"", @"bookingDateTime": @"", @"creditDebit": @"", @"currency": @"", @"description": @"", @"reference": @"", @"relatedAccount": @"", @"relatedName": @"", @"transactionCode": @"", @"valueDateTime": @"" } ] } ], @"cards": @[ @{ @"info": @{ @"availableBalance": @"", @"creditLimit": @"", @"description": @"", @"expiration": @"", @"holderName": @"", @"ledgerBalance": @"", @"number": @"", @"subType": @"", @"type": @"" }, @"party": @{  }, @"statements": @[ @{  } ], @"transactions": @[ @{  } ] } ], @"retryCacheEntries": @[ @{ @"cacheKey": @"", @"count": @0, @"expirationTimestamp": @"" } ], @"userId": @"" } ] };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/sandbox" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/sandbox",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'sandboxId' => '',
    'users' => [
        [
                'accounts' => [
                                [
                                                                'beneficiaries' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                'name' => ''
                                                                                                                                ]
                                                                ],
                                                                'info' => [
                                                                                                                                'accountSubType' => '',
                                                                                                                                'accountType' => '',
                                                                                                                                'alias' => '',
                                                                                                                                'availableBalance' => '',
                                                                                                                                'currency' => '',
                                                                                                                                'description' => '',
                                                                                                                                'iban' => '',
                                                                                                                                'ledgerBalance' => '',
                                                                                                                                'openingDate' => '',
                                                                                                                                'overdraftLimit' => ''
                                                                ],
                                                                'party' => [
                                                                                                                                'id' => '',
                                                                                                                                'name' => ''
                                                                ],
                                                                'scheduledPayments' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                'amount' => '',
                                                                                                                                                                                                                                                                'description' => '',
                                                                                                                                                                                                                                                                'executionDate' => '',
                                                                                                                                                                                                                                                                'senderReference' => ''
                                                                                                                                ]
                                                                ],
                                                                'standingOrders' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                'amount' => '',
                                                                                                                                                                                                                                                                'description' => '',
                                                                                                                                                                                                                                                                'finalPaymentDate' => '',
                                                                                                                                                                                                                                                                'firstPaymentDate' => '',
                                                                                                                                                                                                                                                                'frequency' => '',
                                                                                                                                                                                                                                                                'lastPaymentDate' => '',
                                                                                                                                                                                                                                                                'nextPaymentDate' => '',
                                                                                                                                                                                                                                                                'status' => ''
                                                                                                                                ]
                                                                ],
                                                                'statements' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                'month' => 0,
                                                                                                                                                                                                                                                                'number' => '',
                                                                                                                                                                                                                                                                'year' => 0
                                                                                                                                ]
                                                                ],
                                                                'transactions' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                'accountingBalance' => '',
                                                                                                                                                                                                                                                                'amount' => '',
                                                                                                                                                                                                                                                                'bookingDateTime' => '',
                                                                                                                                                                                                                                                                'creditDebit' => '',
                                                                                                                                                                                                                                                                'currency' => '',
                                                                                                                                                                                                                                                                'description' => '',
                                                                                                                                                                                                                                                                'reference' => '',
                                                                                                                                                                                                                                                                'relatedAccount' => '',
                                                                                                                                                                                                                                                                'relatedName' => '',
                                                                                                                                                                                                                                                                'transactionCode' => '',
                                                                                                                                                                                                                                                                'valueDateTime' => ''
                                                                                                                                ]
                                                                ]
                                ]
                ],
                'cards' => [
                                [
                                                                'info' => [
                                                                                                                                'availableBalance' => '',
                                                                                                                                'creditLimit' => '',
                                                                                                                                'description' => '',
                                                                                                                                'expiration' => '',
                                                                                                                                'holderName' => '',
                                                                                                                                'ledgerBalance' => '',
                                                                                                                                'number' => '',
                                                                                                                                'subType' => '',
                                                                                                                                'type' => ''
                                                                ],
                                                                'party' => [
                                                                                                                                
                                                                ],
                                                                'statements' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                
                                                                                                                                ]
                                                                ],
                                                                'transactions' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                
                                                                                                                                ]
                                                                ]
                                ]
                ],
                'retryCacheEntries' => [
                                [
                                                                'cacheKey' => '',
                                                                'count' => 0,
                                                                'expirationTimestamp' => ''
                                ]
                ],
                'userId' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/sandbox', [
  'body' => '{
  "sandboxId": "",
  "users": [
    {
      "accounts": [
        {
          "beneficiaries": [
            {
              "name": ""
            }
          ],
          "info": {
            "accountSubType": "",
            "accountType": "",
            "alias": "",
            "availableBalance": "",
            "currency": "",
            "description": "",
            "iban": "",
            "ledgerBalance": "",
            "openingDate": "",
            "overdraftLimit": ""
          },
          "party": {
            "id": "",
            "name": ""
          },
          "scheduledPayments": [
            {
              "amount": "",
              "description": "",
              "executionDate": "",
              "senderReference": ""
            }
          ],
          "standingOrders": [
            {
              "amount": "",
              "description": "",
              "finalPaymentDate": "",
              "firstPaymentDate": "",
              "frequency": "",
              "lastPaymentDate": "",
              "nextPaymentDate": "",
              "status": ""
            }
          ],
          "statements": [
            {
              "month": 0,
              "number": "",
              "year": 0
            }
          ],
          "transactions": [
            {
              "accountingBalance": "",
              "amount": "",
              "bookingDateTime": "",
              "creditDebit": "",
              "currency": "",
              "description": "",
              "reference": "",
              "relatedAccount": "",
              "relatedName": "",
              "transactionCode": "",
              "valueDateTime": ""
            }
          ]
        }
      ],
      "cards": [
        {
          "info": {
            "availableBalance": "",
            "creditLimit": "",
            "description": "",
            "expiration": "",
            "holderName": "",
            "ledgerBalance": "",
            "number": "",
            "subType": "",
            "type": ""
          },
          "party": {},
          "statements": [
            {}
          ],
          "transactions": [
            {}
          ]
        }
      ],
      "retryCacheEntries": [
        {
          "cacheKey": "",
          "count": 0,
          "expirationTimestamp": ""
        }
      ],
      "userId": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/sandbox');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'sandboxId' => '',
  'users' => [
    [
        'accounts' => [
                [
                                'beneficiaries' => [
                                                                [
                                                                                                                                'name' => ''
                                                                ]
                                ],
                                'info' => [
                                                                'accountSubType' => '',
                                                                'accountType' => '',
                                                                'alias' => '',
                                                                'availableBalance' => '',
                                                                'currency' => '',
                                                                'description' => '',
                                                                'iban' => '',
                                                                'ledgerBalance' => '',
                                                                'openingDate' => '',
                                                                'overdraftLimit' => ''
                                ],
                                'party' => [
                                                                'id' => '',
                                                                'name' => ''
                                ],
                                'scheduledPayments' => [
                                                                [
                                                                                                                                'amount' => '',
                                                                                                                                'description' => '',
                                                                                                                                'executionDate' => '',
                                                                                                                                'senderReference' => ''
                                                                ]
                                ],
                                'standingOrders' => [
                                                                [
                                                                                                                                'amount' => '',
                                                                                                                                'description' => '',
                                                                                                                                'finalPaymentDate' => '',
                                                                                                                                'firstPaymentDate' => '',
                                                                                                                                'frequency' => '',
                                                                                                                                'lastPaymentDate' => '',
                                                                                                                                'nextPaymentDate' => '',
                                                                                                                                'status' => ''
                                                                ]
                                ],
                                'statements' => [
                                                                [
                                                                                                                                'month' => 0,
                                                                                                                                'number' => '',
                                                                                                                                'year' => 0
                                                                ]
                                ],
                                'transactions' => [
                                                                [
                                                                                                                                'accountingBalance' => '',
                                                                                                                                'amount' => '',
                                                                                                                                'bookingDateTime' => '',
                                                                                                                                'creditDebit' => '',
                                                                                                                                'currency' => '',
                                                                                                                                'description' => '',
                                                                                                                                'reference' => '',
                                                                                                                                'relatedAccount' => '',
                                                                                                                                'relatedName' => '',
                                                                                                                                'transactionCode' => '',
                                                                                                                                'valueDateTime' => ''
                                                                ]
                                ]
                ]
        ],
        'cards' => [
                [
                                'info' => [
                                                                'availableBalance' => '',
                                                                'creditLimit' => '',
                                                                'description' => '',
                                                                'expiration' => '',
                                                                'holderName' => '',
                                                                'ledgerBalance' => '',
                                                                'number' => '',
                                                                'subType' => '',
                                                                'type' => ''
                                ],
                                'party' => [
                                                                
                                ],
                                'statements' => [
                                                                [
                                                                                                                                
                                                                ]
                                ],
                                'transactions' => [
                                                                [
                                                                                                                                
                                                                ]
                                ]
                ]
        ],
        'retryCacheEntries' => [
                [
                                'cacheKey' => '',
                                'count' => 0,
                                'expirationTimestamp' => ''
                ]
        ],
        'userId' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'sandboxId' => '',
  'users' => [
    [
        'accounts' => [
                [
                                'beneficiaries' => [
                                                                [
                                                                                                                                'name' => ''
                                                                ]
                                ],
                                'info' => [
                                                                'accountSubType' => '',
                                                                'accountType' => '',
                                                                'alias' => '',
                                                                'availableBalance' => '',
                                                                'currency' => '',
                                                                'description' => '',
                                                                'iban' => '',
                                                                'ledgerBalance' => '',
                                                                'openingDate' => '',
                                                                'overdraftLimit' => ''
                                ],
                                'party' => [
                                                                'id' => '',
                                                                'name' => ''
                                ],
                                'scheduledPayments' => [
                                                                [
                                                                                                                                'amount' => '',
                                                                                                                                'description' => '',
                                                                                                                                'executionDate' => '',
                                                                                                                                'senderReference' => ''
                                                                ]
                                ],
                                'standingOrders' => [
                                                                [
                                                                                                                                'amount' => '',
                                                                                                                                'description' => '',
                                                                                                                                'finalPaymentDate' => '',
                                                                                                                                'firstPaymentDate' => '',
                                                                                                                                'frequency' => '',
                                                                                                                                'lastPaymentDate' => '',
                                                                                                                                'nextPaymentDate' => '',
                                                                                                                                'status' => ''
                                                                ]
                                ],
                                'statements' => [
                                                                [
                                                                                                                                'month' => 0,
                                                                                                                                'number' => '',
                                                                                                                                'year' => 0
                                                                ]
                                ],
                                'transactions' => [
                                                                [
                                                                                                                                'accountingBalance' => '',
                                                                                                                                'amount' => '',
                                                                                                                                'bookingDateTime' => '',
                                                                                                                                'creditDebit' => '',
                                                                                                                                'currency' => '',
                                                                                                                                'description' => '',
                                                                                                                                'reference' => '',
                                                                                                                                'relatedAccount' => '',
                                                                                                                                'relatedName' => '',
                                                                                                                                'transactionCode' => '',
                                                                                                                                'valueDateTime' => ''
                                                                ]
                                ]
                ]
        ],
        'cards' => [
                [
                                'info' => [
                                                                'availableBalance' => '',
                                                                'creditLimit' => '',
                                                                'description' => '',
                                                                'expiration' => '',
                                                                'holderName' => '',
                                                                'ledgerBalance' => '',
                                                                'number' => '',
                                                                'subType' => '',
                                                                'type' => ''
                                ],
                                'party' => [
                                                                
                                ],
                                'statements' => [
                                                                [
                                                                                                                                
                                                                ]
                                ],
                                'transactions' => [
                                                                [
                                                                                                                                
                                                                ]
                                ]
                ]
        ],
        'retryCacheEntries' => [
                [
                                'cacheKey' => '',
                                'count' => 0,
                                'expirationTimestamp' => ''
                ]
        ],
        'userId' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/sandbox');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/sandbox' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "sandboxId": "",
  "users": [
    {
      "accounts": [
        {
          "beneficiaries": [
            {
              "name": ""
            }
          ],
          "info": {
            "accountSubType": "",
            "accountType": "",
            "alias": "",
            "availableBalance": "",
            "currency": "",
            "description": "",
            "iban": "",
            "ledgerBalance": "",
            "openingDate": "",
            "overdraftLimit": ""
          },
          "party": {
            "id": "",
            "name": ""
          },
          "scheduledPayments": [
            {
              "amount": "",
              "description": "",
              "executionDate": "",
              "senderReference": ""
            }
          ],
          "standingOrders": [
            {
              "amount": "",
              "description": "",
              "finalPaymentDate": "",
              "firstPaymentDate": "",
              "frequency": "",
              "lastPaymentDate": "",
              "nextPaymentDate": "",
              "status": ""
            }
          ],
          "statements": [
            {
              "month": 0,
              "number": "",
              "year": 0
            }
          ],
          "transactions": [
            {
              "accountingBalance": "",
              "amount": "",
              "bookingDateTime": "",
              "creditDebit": "",
              "currency": "",
              "description": "",
              "reference": "",
              "relatedAccount": "",
              "relatedName": "",
              "transactionCode": "",
              "valueDateTime": ""
            }
          ]
        }
      ],
      "cards": [
        {
          "info": {
            "availableBalance": "",
            "creditLimit": "",
            "description": "",
            "expiration": "",
            "holderName": "",
            "ledgerBalance": "",
            "number": "",
            "subType": "",
            "type": ""
          },
          "party": {},
          "statements": [
            {}
          ],
          "transactions": [
            {}
          ]
        }
      ],
      "retryCacheEntries": [
        {
          "cacheKey": "",
          "count": 0,
          "expirationTimestamp": ""
        }
      ],
      "userId": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/sandbox' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "sandboxId": "",
  "users": [
    {
      "accounts": [
        {
          "beneficiaries": [
            {
              "name": ""
            }
          ],
          "info": {
            "accountSubType": "",
            "accountType": "",
            "alias": "",
            "availableBalance": "",
            "currency": "",
            "description": "",
            "iban": "",
            "ledgerBalance": "",
            "openingDate": "",
            "overdraftLimit": ""
          },
          "party": {
            "id": "",
            "name": ""
          },
          "scheduledPayments": [
            {
              "amount": "",
              "description": "",
              "executionDate": "",
              "senderReference": ""
            }
          ],
          "standingOrders": [
            {
              "amount": "",
              "description": "",
              "finalPaymentDate": "",
              "firstPaymentDate": "",
              "frequency": "",
              "lastPaymentDate": "",
              "nextPaymentDate": "",
              "status": ""
            }
          ],
          "statements": [
            {
              "month": 0,
              "number": "",
              "year": 0
            }
          ],
          "transactions": [
            {
              "accountingBalance": "",
              "amount": "",
              "bookingDateTime": "",
              "creditDebit": "",
              "currency": "",
              "description": "",
              "reference": "",
              "relatedAccount": "",
              "relatedName": "",
              "transactionCode": "",
              "valueDateTime": ""
            }
          ]
        }
      ],
      "cards": [
        {
          "info": {
            "availableBalance": "",
            "creditLimit": "",
            "description": "",
            "expiration": "",
            "holderName": "",
            "ledgerBalance": "",
            "number": "",
            "subType": "",
            "type": ""
          },
          "party": {},
          "statements": [
            {}
          ],
          "transactions": [
            {}
          ]
        }
      ],
      "retryCacheEntries": [
        {
          "cacheKey": "",
          "count": 0,
          "expirationTimestamp": ""
        }
      ],
      "userId": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}"

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

conn.request("PUT", "/baseUrl/sandbox", payload, headers)

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

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

import requests

url = "{{baseUrl}}/sandbox"

payload = {
    "sandboxId": "",
    "users": [
        {
            "accounts": [
                {
                    "beneficiaries": [{ "name": "" }],
                    "info": {
                        "accountSubType": "",
                        "accountType": "",
                        "alias": "",
                        "availableBalance": "",
                        "currency": "",
                        "description": "",
                        "iban": "",
                        "ledgerBalance": "",
                        "openingDate": "",
                        "overdraftLimit": ""
                    },
                    "party": {
                        "id": "",
                        "name": ""
                    },
                    "scheduledPayments": [
                        {
                            "amount": "",
                            "description": "",
                            "executionDate": "",
                            "senderReference": ""
                        }
                    ],
                    "standingOrders": [
                        {
                            "amount": "",
                            "description": "",
                            "finalPaymentDate": "",
                            "firstPaymentDate": "",
                            "frequency": "",
                            "lastPaymentDate": "",
                            "nextPaymentDate": "",
                            "status": ""
                        }
                    ],
                    "statements": [
                        {
                            "month": 0,
                            "number": "",
                            "year": 0
                        }
                    ],
                    "transactions": [
                        {
                            "accountingBalance": "",
                            "amount": "",
                            "bookingDateTime": "",
                            "creditDebit": "",
                            "currency": "",
                            "description": "",
                            "reference": "",
                            "relatedAccount": "",
                            "relatedName": "",
                            "transactionCode": "",
                            "valueDateTime": ""
                        }
                    ]
                }
            ],
            "cards": [
                {
                    "info": {
                        "availableBalance": "",
                        "creditLimit": "",
                        "description": "",
                        "expiration": "",
                        "holderName": "",
                        "ledgerBalance": "",
                        "number": "",
                        "subType": "",
                        "type": ""
                    },
                    "party": {},
                    "statements": [{}],
                    "transactions": [{}]
                }
            ],
            "retryCacheEntries": [
                {
                    "cacheKey": "",
                    "count": 0,
                    "expirationTimestamp": ""
                }
            ],
            "userId": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/sandbox') do |req|
  req.body = "{\n  \"sandboxId\": \"\",\n  \"users\": [\n    {\n      \"accounts\": [\n        {\n          \"beneficiaries\": [\n            {\n              \"name\": \"\"\n            }\n          ],\n          \"info\": {\n            \"accountSubType\": \"\",\n            \"accountType\": \"\",\n            \"alias\": \"\",\n            \"availableBalance\": \"\",\n            \"currency\": \"\",\n            \"description\": \"\",\n            \"iban\": \"\",\n            \"ledgerBalance\": \"\",\n            \"openingDate\": \"\",\n            \"overdraftLimit\": \"\"\n          },\n          \"party\": {\n            \"id\": \"\",\n            \"name\": \"\"\n          },\n          \"scheduledPayments\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"executionDate\": \"\",\n              \"senderReference\": \"\"\n            }\n          ],\n          \"standingOrders\": [\n            {\n              \"amount\": \"\",\n              \"description\": \"\",\n              \"finalPaymentDate\": \"\",\n              \"firstPaymentDate\": \"\",\n              \"frequency\": \"\",\n              \"lastPaymentDate\": \"\",\n              \"nextPaymentDate\": \"\",\n              \"status\": \"\"\n            }\n          ],\n          \"statements\": [\n            {\n              \"month\": 0,\n              \"number\": \"\",\n              \"year\": 0\n            }\n          ],\n          \"transactions\": [\n            {\n              \"accountingBalance\": \"\",\n              \"amount\": \"\",\n              \"bookingDateTime\": \"\",\n              \"creditDebit\": \"\",\n              \"currency\": \"\",\n              \"description\": \"\",\n              \"reference\": \"\",\n              \"relatedAccount\": \"\",\n              \"relatedName\": \"\",\n              \"transactionCode\": \"\",\n              \"valueDateTime\": \"\"\n            }\n          ]\n        }\n      ],\n      \"cards\": [\n        {\n          \"info\": {\n            \"availableBalance\": \"\",\n            \"creditLimit\": \"\",\n            \"description\": \"\",\n            \"expiration\": \"\",\n            \"holderName\": \"\",\n            \"ledgerBalance\": \"\",\n            \"number\": \"\",\n            \"subType\": \"\",\n            \"type\": \"\"\n          },\n          \"party\": {},\n          \"statements\": [\n            {}\n          ],\n          \"transactions\": [\n            {}\n          ]\n        }\n      ],\n      \"retryCacheEntries\": [\n        {\n          \"cacheKey\": \"\",\n          \"count\": 0,\n          \"expirationTimestamp\": \"\"\n        }\n      ],\n      \"userId\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "sandboxId": "",
        "users": (
            json!({
                "accounts": (
                    json!({
                        "beneficiaries": (json!({"name": ""})),
                        "info": json!({
                            "accountSubType": "",
                            "accountType": "",
                            "alias": "",
                            "availableBalance": "",
                            "currency": "",
                            "description": "",
                            "iban": "",
                            "ledgerBalance": "",
                            "openingDate": "",
                            "overdraftLimit": ""
                        }),
                        "party": json!({
                            "id": "",
                            "name": ""
                        }),
                        "scheduledPayments": (
                            json!({
                                "amount": "",
                                "description": "",
                                "executionDate": "",
                                "senderReference": ""
                            })
                        ),
                        "standingOrders": (
                            json!({
                                "amount": "",
                                "description": "",
                                "finalPaymentDate": "",
                                "firstPaymentDate": "",
                                "frequency": "",
                                "lastPaymentDate": "",
                                "nextPaymentDate": "",
                                "status": ""
                            })
                        ),
                        "statements": (
                            json!({
                                "month": 0,
                                "number": "",
                                "year": 0
                            })
                        ),
                        "transactions": (
                            json!({
                                "accountingBalance": "",
                                "amount": "",
                                "bookingDateTime": "",
                                "creditDebit": "",
                                "currency": "",
                                "description": "",
                                "reference": "",
                                "relatedAccount": "",
                                "relatedName": "",
                                "transactionCode": "",
                                "valueDateTime": ""
                            })
                        )
                    })
                ),
                "cards": (
                    json!({
                        "info": json!({
                            "availableBalance": "",
                            "creditLimit": "",
                            "description": "",
                            "expiration": "",
                            "holderName": "",
                            "ledgerBalance": "",
                            "number": "",
                            "subType": "",
                            "type": ""
                        }),
                        "party": json!({}),
                        "statements": (json!({})),
                        "transactions": (json!({}))
                    })
                ),
                "retryCacheEntries": (
                    json!({
                        "cacheKey": "",
                        "count": 0,
                        "expirationTimestamp": ""
                    })
                ),
                "userId": ""
            })
        )
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "sandboxId": "",
  "users": [
    {
      "accounts": [
        {
          "beneficiaries": [
            {
              "name": ""
            }
          ],
          "info": {
            "accountSubType": "",
            "accountType": "",
            "alias": "",
            "availableBalance": "",
            "currency": "",
            "description": "",
            "iban": "",
            "ledgerBalance": "",
            "openingDate": "",
            "overdraftLimit": ""
          },
          "party": {
            "id": "",
            "name": ""
          },
          "scheduledPayments": [
            {
              "amount": "",
              "description": "",
              "executionDate": "",
              "senderReference": ""
            }
          ],
          "standingOrders": [
            {
              "amount": "",
              "description": "",
              "finalPaymentDate": "",
              "firstPaymentDate": "",
              "frequency": "",
              "lastPaymentDate": "",
              "nextPaymentDate": "",
              "status": ""
            }
          ],
          "statements": [
            {
              "month": 0,
              "number": "",
              "year": 0
            }
          ],
          "transactions": [
            {
              "accountingBalance": "",
              "amount": "",
              "bookingDateTime": "",
              "creditDebit": "",
              "currency": "",
              "description": "",
              "reference": "",
              "relatedAccount": "",
              "relatedName": "",
              "transactionCode": "",
              "valueDateTime": ""
            }
          ]
        }
      ],
      "cards": [
        {
          "info": {
            "availableBalance": "",
            "creditLimit": "",
            "description": "",
            "expiration": "",
            "holderName": "",
            "ledgerBalance": "",
            "number": "",
            "subType": "",
            "type": ""
          },
          "party": {},
          "statements": [
            {}
          ],
          "transactions": [
            {}
          ]
        }
      ],
      "retryCacheEntries": [
        {
          "cacheKey": "",
          "count": 0,
          "expirationTimestamp": ""
        }
      ],
      "userId": ""
    }
  ]
}' |  \
  http PUT {{baseUrl}}/sandbox \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "sandboxId": "",\n  "users": [\n    {\n      "accounts": [\n        {\n          "beneficiaries": [\n            {\n              "name": ""\n            }\n          ],\n          "info": {\n            "accountSubType": "",\n            "accountType": "",\n            "alias": "",\n            "availableBalance": "",\n            "currency": "",\n            "description": "",\n            "iban": "",\n            "ledgerBalance": "",\n            "openingDate": "",\n            "overdraftLimit": ""\n          },\n          "party": {\n            "id": "",\n            "name": ""\n          },\n          "scheduledPayments": [\n            {\n              "amount": "",\n              "description": "",\n              "executionDate": "",\n              "senderReference": ""\n            }\n          ],\n          "standingOrders": [\n            {\n              "amount": "",\n              "description": "",\n              "finalPaymentDate": "",\n              "firstPaymentDate": "",\n              "frequency": "",\n              "lastPaymentDate": "",\n              "nextPaymentDate": "",\n              "status": ""\n            }\n          ],\n          "statements": [\n            {\n              "month": 0,\n              "number": "",\n              "year": 0\n            }\n          ],\n          "transactions": [\n            {\n              "accountingBalance": "",\n              "amount": "",\n              "bookingDateTime": "",\n              "creditDebit": "",\n              "currency": "",\n              "description": "",\n              "reference": "",\n              "relatedAccount": "",\n              "relatedName": "",\n              "transactionCode": "",\n              "valueDateTime": ""\n            }\n          ]\n        }\n      ],\n      "cards": [\n        {\n          "info": {\n            "availableBalance": "",\n            "creditLimit": "",\n            "description": "",\n            "expiration": "",\n            "holderName": "",\n            "ledgerBalance": "",\n            "number": "",\n            "subType": "",\n            "type": ""\n          },\n          "party": {},\n          "statements": [\n            {}\n          ],\n          "transactions": [\n            {}\n          ]\n        }\n      ],\n      "retryCacheEntries": [\n        {\n          "cacheKey": "",\n          "count": 0,\n          "expirationTimestamp": ""\n        }\n      ],\n      "userId": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/sandbox

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "sandboxId": "",
  "users": [
    [
      "accounts": [
        [
          "beneficiaries": [["name": ""]],
          "info": [
            "accountSubType": "",
            "accountType": "",
            "alias": "",
            "availableBalance": "",
            "currency": "",
            "description": "",
            "iban": "",
            "ledgerBalance": "",
            "openingDate": "",
            "overdraftLimit": ""
          ],
          "party": [
            "id": "",
            "name": ""
          ],
          "scheduledPayments": [
            [
              "amount": "",
              "description": "",
              "executionDate": "",
              "senderReference": ""
            ]
          ],
          "standingOrders": [
            [
              "amount": "",
              "description": "",
              "finalPaymentDate": "",
              "firstPaymentDate": "",
              "frequency": "",
              "lastPaymentDate": "",
              "nextPaymentDate": "",
              "status": ""
            ]
          ],
          "statements": [
            [
              "month": 0,
              "number": "",
              "year": 0
            ]
          ],
          "transactions": [
            [
              "accountingBalance": "",
              "amount": "",
              "bookingDateTime": "",
              "creditDebit": "",
              "currency": "",
              "description": "",
              "reference": "",
              "relatedAccount": "",
              "relatedName": "",
              "transactionCode": "",
              "valueDateTime": ""
            ]
          ]
        ]
      ],
      "cards": [
        [
          "info": [
            "availableBalance": "",
            "creditLimit": "",
            "description": "",
            "expiration": "",
            "holderName": "",
            "ledgerBalance": "",
            "number": "",
            "subType": "",
            "type": ""
          ],
          "party": [],
          "statements": [[]],
          "transactions": [[]]
        ]
      ],
      "retryCacheEntries": [
        [
          "cacheKey": "",
          "count": 0,
          "expirationTimestamp": ""
        ]
      ],
      "userId": ""
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/scheduled-payments");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/:accountId/scheduled-payments" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/scheduled-payments"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/scheduled-payments"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts/:accountId/scheduled-payments HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/scheduled-payments"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/scheduled-payments")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/scheduled-payments")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/scheduled-payments');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/scheduled-payments',
  headers: {'sandbox-id': ''}
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/scheduled-payments")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/scheduled-payments',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/scheduled-payments',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/scheduled-payments');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/scheduled-payments',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/scheduled-payments';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/scheduled-payments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/scheduled-payments" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/accounts/:accountId/scheduled-payments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accounts/:accountId/scheduled-payments', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/scheduled-payments');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accounts/:accountId/scheduled-payments');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/scheduled-payments' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/scheduled-payments' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/scheduled-payments", headers=headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/scheduled-payments"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/scheduled-payments"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/scheduled-payments")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/accounts/:accountId/scheduled-payments') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/scheduled-payments \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/scheduled-payments

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/standing-orders");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/:accountId/standing-orders" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/standing-orders"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/standing-orders"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts/:accountId/standing-orders HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/standing-orders"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/standing-orders")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/standing-orders")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/standing-orders');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/standing-orders',
  headers: {'sandbox-id': ''}
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/standing-orders")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/standing-orders',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/standing-orders',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/standing-orders');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/standing-orders',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/standing-orders';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/standing-orders"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/standing-orders" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/accounts/:accountId/standing-orders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accounts/:accountId/standing-orders', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/standing-orders');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accounts/:accountId/standing-orders');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/standing-orders' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/standing-orders' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/standing-orders", headers=headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/standing-orders"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/standing-orders"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/standing-orders")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/accounts/:accountId/standing-orders') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/standing-orders \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/standing-orders

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/statements/:statementId/file");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/:accountId/statements/:statementId/file" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/statements/:statementId/file"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:accountId/statements/:statementId/file"),
    Headers =
    {
        { "sandbox-id", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:accountId/statements/:statementId/file");
var request = new RestRequest("", Method.Get);
request.AddHeader("sandbox-id", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/statements/:statementId/file"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts/:accountId/statements/:statementId/file HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/statements/:statementId/file"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/statements/:statementId/file")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/statements/:statementId/file")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/statements/:statementId/file');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/statements/:statementId/file',
  headers: {'sandbox-id': ''}
};

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

const url = '{{baseUrl}}/accounts/:accountId/statements/:statementId/file';
const options = {method: 'GET', headers: {'sandbox-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}}/accounts/:accountId/statements/:statementId/file',
  method: 'GET',
  headers: {
    'sandbox-id': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/statements/:statementId/file")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/statements/:statementId/file',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/statements/:statementId/file',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/statements/:statementId/file');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/statements/:statementId/file',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/statements/:statementId/file';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/statements/:statementId/file"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/statements/:statementId/file" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

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

 "{{baseUrl}}/accounts/:accountId/statements/:statementId/file",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accounts/:accountId/statements/:statementId/file', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/statements/:statementId/file');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sandbox-id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accounts/:accountId/statements/:statementId/file');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/statements/:statementId/file' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/statements/:statementId/file' -Method GET -Headers $headers

import http.client

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

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/statements/:statementId/file", headers=headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/statements/:statementId/file"

headers = {"sandbox-id": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/statements/:statementId/file"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/statements/:statementId/file")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/accounts/:accountId/statements/:statementId/file') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/statements/:statementId/file";

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/statements/:statementId/file \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/statements/:statementId/file

import Foundation

let headers = ["sandbox-id": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/statements/:statementId");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/:accountId/statements/:statementId" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/statements/:statementId"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/statements/:statementId"

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

	req.Header.Add("sandbox-id", "")

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

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

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

}

GET /baseUrl/accounts/:accountId/statements/:statementId HTTP/1.1
Sandbox-Id: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/statements/:statementId"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/statements/:statementId")
  .get()
  .addHeader("sandbox-id", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/statements/:statementId")
  .header("sandbox-id", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/statements/:statementId');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/statements/:statementId',
  headers: {'sandbox-id': ''}
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/statements/:statementId")
  .get()
  .addHeader("sandbox-id", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/statements/:statementId',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/statements/:statementId',
  headers: {'sandbox-id': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/statements/:statementId');

req.headers({
  'sandbox-id': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/statements/:statementId',
  headers: {'sandbox-id': ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/statements/:statementId';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

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

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/statements/:statementId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/statements/:statementId" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId/statements/:statementId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:accountId/statements/:statementId', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/statements/:statementId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sandbox-id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:accountId/statements/:statementId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/statements/:statementId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/statements/:statementId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/statements/:statementId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId/statements/:statementId"

headers = {"sandbox-id": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/statements/:statementId"

response <- VERB("GET", url, add_headers('sandbox-id' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/statements/:statementId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sandbox-id"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:accountId/statements/:statementId') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/statements/:statementId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sandbox-id", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/statements/:statementId \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/statements/:statementId

import Foundation

let headers = ["sandbox-id": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/statements/:statementId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/statements");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sandbox-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:accountId/statements" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/statements"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:accountId/statements"),
    Headers =
    {
        { "sandbox-id", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:accountId/statements");
var request = new RestRequest("", Method.Get);
request.AddHeader("sandbox-id", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:accountId/statements"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sandbox-id", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:accountId/statements HTTP/1.1
Sandbox-Id: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:accountId/statements")
  .setHeader("sandbox-id", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/statements"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/statements")
  .get()
  .addHeader("sandbox-id", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/statements")
  .header("sandbox-id", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/statements');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/statements',
  headers: {'sandbox-id': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:accountId/statements';
const options = {method: 'GET', headers: {'sandbox-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}}/accounts/:accountId/statements',
  method: 'GET',
  headers: {
    'sandbox-id': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/statements")
  .get()
  .addHeader("sandbox-id", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/statements',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/statements',
  headers: {'sandbox-id': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/statements');

req.headers({
  'sandbox-id': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/statements',
  headers: {'sandbox-id': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:accountId/statements';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/statements"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/statements" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId/statements",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:accountId/statements', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/statements');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sandbox-id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:accountId/statements');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/statements' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/statements' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/statements", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId/statements"

headers = {"sandbox-id": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/statements"

response <- VERB("GET", url, add_headers('sandbox-id' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/statements")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sandbox-id"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:accountId/statements') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/statements";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sandbox-id", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/statements \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/statements

import Foundation

let headers = ["sandbox-id": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/statements")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/transactions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sandbox-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:accountId/transactions" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/transactions"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:accountId/transactions"),
    Headers =
    {
        { "sandbox-id", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:accountId/transactions");
var request = new RestRequest("", Method.Get);
request.AddHeader("sandbox-id", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:accountId/transactions"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sandbox-id", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:accountId/transactions HTTP/1.1
Sandbox-Id: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:accountId/transactions")
  .setHeader("sandbox-id", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/transactions"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/transactions")
  .get()
  .addHeader("sandbox-id", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/transactions")
  .header("sandbox-id", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/transactions');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/transactions',
  headers: {'sandbox-id': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:accountId/transactions';
const options = {method: 'GET', headers: {'sandbox-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}}/accounts/:accountId/transactions',
  method: 'GET',
  headers: {
    'sandbox-id': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/transactions")
  .get()
  .addHeader("sandbox-id", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/transactions',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/transactions',
  headers: {'sandbox-id': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/transactions');

req.headers({
  'sandbox-id': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/transactions',
  headers: {'sandbox-id': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:accountId/transactions';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/transactions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/transactions" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId/transactions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:accountId/transactions', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/transactions');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sandbox-id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:accountId/transactions');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/transactions' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/transactions' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/transactions", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId/transactions"

headers = {"sandbox-id": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/transactions"

response <- VERB("GET", url, add_headers('sandbox-id' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/transactions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sandbox-id"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:accountId/transactions') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/transactions";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sandbox-id", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/transactions \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/transactions

import Foundation

let headers = ["sandbox-id": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/transactions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sandbox-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions" {:headers {:sandbox-id ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions"
headers = HTTP::Headers{
  "sandbox-id" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions"),
    Headers =
    {
        { "sandbox-id", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions");
var request = new RestRequest("", Method.Get);
request.AddHeader("sandbox-id", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sandbox-id", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:accountId/statements/:statementId/transactions HTTP/1.1
Sandbox-Id: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions")
  .setHeader("sandbox-id", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions"))
    .header("sandbox-id", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions")
  .get()
  .addHeader("sandbox-id", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions")
  .header("sandbox-id", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions');
xhr.setRequestHeader('sandbox-id', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions',
  headers: {'sandbox-id': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions';
const options = {method: 'GET', headers: {'sandbox-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}}/accounts/:accountId/statements/:statementId/transactions',
  method: 'GET',
  headers: {
    'sandbox-id': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions")
  .get()
  .addHeader("sandbox-id", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/statements/:statementId/transactions',
  headers: {
    'sandbox-id': ''
  }
};

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}}/accounts/:accountId/statements/:statementId/transactions',
  headers: {'sandbox-id': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions');

req.headers({
  'sandbox-id': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions',
  headers: {'sandbox-id': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions';
const options = {method: 'GET', headers: {'sandbox-id': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sandbox-id": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions" in
let headers = Header.add (Header.init ()) "sandbox-id" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sandbox-id: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions', [
  'headers' => [
    'sandbox-id' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sandbox-id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sandbox-id' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sandbox-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sandbox-id': "" }

conn.request("GET", "/baseUrl/accounts/:accountId/statements/:statementId/transactions", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions"

headers = {"sandbox-id": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions"

response <- VERB("GET", url, add_headers('sandbox-id' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sandbox-id"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:accountId/statements/:statementId/transactions') do |req|
  req.headers['sandbox-id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sandbox-id", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/accounts/:accountId/statements/:statementId/transactions \
  sandbox-id:''

wget --quiet \
  --method GET \
  --header 'sandbox-id: ' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/statements/:statementId/transactions

import Foundation

let headers = ["sandbox-id": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/statements/:statementId/transactions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()