CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment" {:headers {:user-agent ""
                                                                                                                   :x-bunq-client-authentication ""}
                                                                                                         :content-type :json})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/user/:userID/monetary-account/:monetary-accountID/attachment"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{}")
    {
        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}}/user/:userID/monetary-account/:monetary-accountID/attachment");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment"

	payload := strings.NewReader("{}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/monetary-account/:monetary-accountID/attachment HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .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, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {}
};

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/monetary-account/:monetary-accountID/attachment',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({});

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}}/user/:userID/monetary-account/:monetary-accountID/attachment',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {}
};

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

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/attachment" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment",
  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([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/attachment", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment"

payload = {}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment")

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

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{}"

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/user/:userID/monetary-account/:monetary-accountID/attachment') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{}' |  \
  http POST {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/attachment/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/attachment/:itemId" {:headers {:user-agent ""
                                                                                     :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/attachment/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/attachment/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/attachment/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/attachment/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/attachment/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/attachment/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/attachment/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/attachment/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/attachment/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/attachment/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/attachment/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/attachment/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/attachment/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/attachment/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/attachment/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/attachment/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/attachment/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/attachment/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/attachment/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/attachment/:itemId"]
                                                       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}}/user/:userID/attachment/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/attachment/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/attachment/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/attachment/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/attachment/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/attachment/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/attachment/:itemId' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/attachment/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/attachment/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/attachment/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/attachment/:itemId")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/attachment/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/attachment/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/attachment/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/attachment-public" {:headers {:user-agent ""
                                                                        :x-bunq-client-authentication ""}
                                                              :content-type :json})

require "http/client"

url = "{{baseUrl}}/attachment-public"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/attachment-public"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{}")
    {
        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}}/attachment-public");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/attachment-public"

	payload := strings.NewReader("{}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/attachment-public HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/attachment-public")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/attachment-public"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .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, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/attachment-public")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/attachment-public")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/attachment-public');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/attachment-public',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {}
};

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

const url = '{{baseUrl}}/attachment-public';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/attachment-public',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/attachment-public")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/attachment-public',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/attachment-public',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/attachment-public');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({});

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}}/attachment-public',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {}
};

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

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

const url = '{{baseUrl}}/attachment-public';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/attachment-public"]
                                                       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}}/attachment-public" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/attachment-public",
  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([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/attachment-public', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/attachment-public');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/attachment-public' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/attachment-public' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/attachment-public", payload, headers)

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

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

import requests

url = "{{baseUrl}}/attachment-public"

payload = {}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/attachment-public"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/attachment-public")

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

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{}"

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/attachment-public') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{}' |  \
  http POST {{baseUrl}}/attachment-public \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/attachment-public

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/attachment-public/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/attachment-public/:itemId" {:headers {:user-agent ""
                                                                               :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/attachment-public/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/attachment-public/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/attachment-public/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/attachment-public/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/attachment-public/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/attachment-public/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/attachment-public/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/attachment-public/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/attachment-public/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/attachment-public/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/attachment-public/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/attachment-public/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/attachment-public/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/attachment-public/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/attachment-public/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/attachment-public/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/attachment-public/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/attachment-public/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/attachment-public/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/attachment-public/:itemId"]
                                                       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}}/attachment-public/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/attachment-public/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/attachment-public/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/attachment-public/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/attachment-public/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/attachment-public/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/attachment-public/:itemId' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/attachment-public/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/attachment-public/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/attachment-public/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/attachment-public/:itemId")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/attachment-public/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/attachment-public/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/attachment-public/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/avatar" {:headers {:user-agent ""
                                                             :x-bunq-client-authentication ""}
                                                   :content-type :json
                                                   :form-params {:anchor_uuid ""
                                                                 :image [{:attachment_public_uuid ""
                                                                          :content_type ""
                                                                          :height 0
                                                                          :width 0}]
                                                                 :style ""
                                                                 :uuid ""}})

require "http/client"

url = "{{baseUrl}}/avatar"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\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}}/avatar"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\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}}/avatar");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/avatar HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 180

{
  "anchor_uuid": "",
  "image": [
    {
      "attachment_public_uuid": "",
      "content_type": "",
      "height": 0,
      "width": 0
    }
  ],
  "style": "",
  "uuid": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/avatar")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/avatar"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\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  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/avatar")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/avatar")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  anchor_uuid: '',
  image: [
    {
      attachment_public_uuid: '',
      content_type: '',
      height: 0,
      width: 0
    }
  ],
  style: '',
  uuid: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/avatar');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/avatar',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    anchor_uuid: '',
    image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
    style: '',
    uuid: ''
  }
};

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

const url = '{{baseUrl}}/avatar';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"anchor_uuid":"","image":[{"attachment_public_uuid":"","content_type":"","height":0,"width":0}],"style":"","uuid":""}'
};

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}}/avatar',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "anchor_uuid": "",\n  "image": [\n    {\n      "attachment_public_uuid": "",\n      "content_type": "",\n      "height": 0,\n      "width": 0\n    }\n  ],\n  "style": "",\n  "uuid": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/avatar")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/avatar',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({
  anchor_uuid: '',
  image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
  style: '',
  uuid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/avatar',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    anchor_uuid: '',
    image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
    style: '',
    uuid: ''
  },
  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}}/avatar');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  anchor_uuid: '',
  image: [
    {
      attachment_public_uuid: '',
      content_type: '',
      height: 0,
      width: 0
    }
  ],
  style: '',
  uuid: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/avatar',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    anchor_uuid: '',
    image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
    style: '',
    uuid: ''
  }
};

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

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

const url = '{{baseUrl}}/avatar';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"anchor_uuid":"","image":[{"attachment_public_uuid":"","content_type":"","height":0,"width":0}],"style":"","uuid":""}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"anchor_uuid": @"",
                              @"image": @[ @{ @"attachment_public_uuid": @"", @"content_type": @"", @"height": @0, @"width": @0 } ],
                              @"style": @"",
                              @"uuid": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/avatar"]
                                                       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}}/avatar" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}" in

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

 "{{baseUrl}}/avatar",
  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([
    'anchor_uuid' => '',
    'image' => [
        [
                'attachment_public_uuid' => '',
                'content_type' => '',
                'height' => 0,
                'width' => 0
        ]
    ],
    'style' => '',
    'uuid' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/avatar', [
  'body' => '{
  "anchor_uuid": "",
  "image": [
    {
      "attachment_public_uuid": "",
      "content_type": "",
      "height": 0,
      "width": 0
    }
  ],
  "style": "",
  "uuid": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'anchor_uuid' => '',
  'image' => [
    [
        'attachment_public_uuid' => '',
        'content_type' => '',
        'height' => 0,
        'width' => 0
    ]
  ],
  'style' => '',
  'uuid' => ''
]));

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

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

append(json_encode([
  'anchor_uuid' => '',
  'image' => [
    [
        'attachment_public_uuid' => '',
        'content_type' => '',
        'height' => 0,
        'width' => 0
    ]
  ],
  'style' => '',
  'uuid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/avatar');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/avatar' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "anchor_uuid": "",
  "image": [
    {
      "attachment_public_uuid": "",
      "content_type": "",
      "height": 0,
      "width": 0
    }
  ],
  "style": "",
  "uuid": ""
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/avatar' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "anchor_uuid": "",
  "image": [
    {
      "attachment_public_uuid": "",
      "content_type": "",
      "height": 0,
      "width": 0
    }
  ],
  "style": "",
  "uuid": ""
}'

import http.client

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

payload = "{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/avatar"

payload = {
    "anchor_uuid": "",
    "image": [
        {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
        }
    ],
    "style": "",
    "uuid": ""
}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\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/avatar') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"anchor_uuid\": \"\",\n  \"image\": [\n    {\n      \"attachment_public_uuid\": \"\",\n      \"content_type\": \"\",\n      \"height\": 0,\n      \"width\": 0\n    }\n  ],\n  \"style\": \"\",\n  \"uuid\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "anchor_uuid": "",
        "image": (
            json!({
                "attachment_public_uuid": "",
                "content_type": "",
                "height": 0,
                "width": 0
            })
        ),
        "style": "",
        "uuid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "anchor_uuid": "",
  "image": [
    {
      "attachment_public_uuid": "",
      "content_type": "",
      "height": 0,
      "width": 0
    }
  ],
  "style": "",
  "uuid": ""
}' |  \
  http POST {{baseUrl}}/avatar \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "anchor_uuid": "",\n  "image": [\n    {\n      "attachment_public_uuid": "",\n      "content_type": "",\n      "height": 0,\n      "width": 0\n    }\n  ],\n  "style": "",\n  "uuid": ""\n}' \
  --output-document \
  - {{baseUrl}}/avatar

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [
  "anchor_uuid": "",
  "image": [
    [
      "attachment_public_uuid": "",
      "content_type": "",
      "height": 0,
      "width": 0
    ]
  ],
  "style": "",
  "uuid": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/avatar/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/avatar/:itemId" {:headers {:user-agent ""
                                                                    :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/avatar/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/avatar/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/avatar/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/avatar/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/avatar/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/avatar/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/avatar/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/avatar/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/avatar/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/avatar/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/avatar/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/avatar/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/avatar/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/avatar/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/avatar/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/avatar/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/avatar/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/avatar/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/avatar/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/avatar/:itemId"]
                                                       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}}/avatar/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/avatar/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/avatar/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/avatar/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/avatar/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/avatar/:itemId' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/avatar/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/avatar/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/avatar/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/avatar/:itemId")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/avatar/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/avatar/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/avatar/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/avatar/:itemId")! 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}}/user/:userID/billing-contract-subscription");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/billing-contract-subscription" {:headers {:user-agent ""
                                                                                                :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/billing-contract-subscription"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/billing-contract-subscription"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/billing-contract-subscription");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/billing-contract-subscription"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/billing-contract-subscription HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/billing-contract-subscription")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/billing-contract-subscription"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/billing-contract-subscription")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/billing-contract-subscription")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/billing-contract-subscription');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/billing-contract-subscription',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/billing-contract-subscription';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/billing-contract-subscription',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/billing-contract-subscription")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/billing-contract-subscription',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/billing-contract-subscription',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/billing-contract-subscription');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/billing-contract-subscription',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/billing-contract-subscription';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/billing-contract-subscription"]
                                                       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}}/user/:userID/billing-contract-subscription" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/billing-contract-subscription",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/billing-contract-subscription', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/billing-contract-subscription');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/billing-contract-subscription');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/billing-contract-subscription' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/billing-contract-subscription' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/billing-contract-subscription", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/billing-contract-subscription"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/billing-contract-subscription"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/billing-contract-subscription")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/billing-contract-subscription') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/billing-contract-subscription";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/billing-contract-subscription \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/billing-contract-subscription

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/billing-contract-subscription")! 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}}/user/:userID/bunqme-fundraiser-profile");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile" {:headers {:user-agent ""
                                                                                            :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/bunqme-fundraiser-profile"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/bunqme-fundraiser-profile HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/bunqme-fundraiser-profile")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/bunqme-fundraiser-profile');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/bunqme-fundraiser-profile',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/bunqme-fundraiser-profile',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/bunqme-fundraiser-profile',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/bunqme-fundraiser-profile',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/bunqme-fundraiser-profile"]
                                                       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}}/user/:userID/bunqme-fundraiser-profile" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/bunqme-fundraiser-profile');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/bunqme-fundraiser-profile');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/bunqme-fundraiser-profile", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/bunqme-fundraiser-profile') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/bunqme-fundraiser-profile \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/bunqme-fundraiser-profile

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile")! 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}}/user/:userID/bunqme-fundraiser-profile/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId" {:headers {:user-agent ""
                                                                                                    :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/bunqme-fundraiser-profile/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/bunqme-fundraiser-profile/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/bunqme-fundraiser-profile/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/bunqme-fundraiser-profile/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/bunqme-fundraiser-profile/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/bunqme-fundraiser-profile/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/bunqme-fundraiser-profile/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/bunqme-fundraiser-profile/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId"]
                                                       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}}/user/:userID/bunqme-fundraiser-profile/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/bunqme-fundraiser-profile/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/bunqme-fundraiser-profile/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/bunqme-fundraiser-profile/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/bunqme-fundraiser-profile/:itemId")! 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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId" {:headers {:user-agent ""
                                                                                                                                        :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-fundraiser-result/:itemId")! 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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab" {:headers {:user-agent ""
                                                                                                                   :x-bunq-client-authentication ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:bunqme_tab_entry {:alias {:avatar {:anchor_uuid ""
                                                                                                                                                           :image [{:attachment_public_uuid ""
                                                                                                                                                                    :content_type ""
                                                                                                                                                                    :height 0
                                                                                                                                                                    :width 0}]
                                                                                                                                                           :style ""
                                                                                                                                                           :uuid ""}
                                                                                                                                                  :bunq_me {:name ""
                                                                                                                                                            :service ""
                                                                                                                                                            :type ""
                                                                                                                                                            :value ""}
                                                                                                                                                  :country ""
                                                                                                                                                  :display_name ""
                                                                                                                                                  :iban ""
                                                                                                                                                  :is_light false
                                                                                                                                                  :label_user {:avatar {}
                                                                                                                                                               :country ""
                                                                                                                                                               :display_name ""
                                                                                                                                                               :public_nick_name ""
                                                                                                                                                               :uuid ""}
                                                                                                                                                  :merchant_category_code ""
                                                                                                                                                  :swift_account_number ""
                                                                                                                                                  :swift_bic ""
                                                                                                                                                  :transferwise_account_number ""
                                                                                                                                                  :transferwise_bank_code ""}
                                                                                                                                          :amount_inquired {:currency ""
                                                                                                                                                            :value ""}
                                                                                                                                          :description ""
                                                                                                                                          :invite_profile_name ""
                                                                                                                                          :merchant_available [{:available false
                                                                                                                                                                :merchant_type ""}]
                                                                                                                                          :redirect_url ""
                                                                                                                                          :status ""
                                                                                                                                          :uuid ""}
                                                                                                                       :status ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"

	payload := strings.NewReader("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/monetary-account/:monetary-accountID/bunqme-tab HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 1154

{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  bunqme_tab_entry: {
    alias: {
      avatar: {
        anchor_uuid: '',
        image: [
          {
            attachment_public_uuid: '',
            content_type: '',
            height: 0,
            width: 0
          }
        ],
        style: '',
        uuid: ''
      },
      bunq_me: {
        name: '',
        service: '',
        type: '',
        value: ''
      },
      country: '',
      display_name: '',
      iban: '',
      is_light: false,
      label_user: {
        avatar: {},
        country: '',
        display_name: '',
        public_nick_name: '',
        uuid: ''
      },
      merchant_category_code: '',
      swift_account_number: '',
      swift_bic: '',
      transferwise_account_number: '',
      transferwise_bank_code: ''
    },
    amount_inquired: {
      currency: '',
      value: ''
    },
    description: '',
    invite_profile_name: '',
    merchant_available: [
      {
        available: false,
        merchant_type: ''
      }
    ],
    redirect_url: '',
    status: '',
    uuid: ''
  },
  status: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    bunqme_tab_entry: {
      alias: {
        avatar: {
          anchor_uuid: '',
          image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
          style: '',
          uuid: ''
        },
        bunq_me: {name: '', service: '', type: '', value: ''},
        country: '',
        display_name: '',
        iban: '',
        is_light: false,
        label_user: {avatar: {}, country: '', display_name: '', public_nick_name: '', uuid: ''},
        merchant_category_code: '',
        swift_account_number: '',
        swift_bic: '',
        transferwise_account_number: '',
        transferwise_bank_code: ''
      },
      amount_inquired: {currency: '', value: ''},
      description: '',
      invite_profile_name: '',
      merchant_available: [{available: false, merchant_type: ''}],
      redirect_url: '',
      status: '',
      uuid: ''
    },
    status: ''
  }
};

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"bunqme_tab_entry":{"alias":{"avatar":{"anchor_uuid":"","image":[{"attachment_public_uuid":"","content_type":"","height":0,"width":0}],"style":"","uuid":""},"bunq_me":{"name":"","service":"","type":"","value":""},"country":"","display_name":"","iban":"","is_light":false,"label_user":{"avatar":{},"country":"","display_name":"","public_nick_name":"","uuid":""},"merchant_category_code":"","swift_account_number":"","swift_bic":"","transferwise_account_number":"","transferwise_bank_code":""},"amount_inquired":{"currency":"","value":""},"description":"","invite_profile_name":"","merchant_available":[{"available":false,"merchant_type":""}],"redirect_url":"","status":"","uuid":""},"status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "bunqme_tab_entry": {\n    "alias": {\n      "avatar": {\n        "anchor_uuid": "",\n        "image": [\n          {\n            "attachment_public_uuid": "",\n            "content_type": "",\n            "height": 0,\n            "width": 0\n          }\n        ],\n        "style": "",\n        "uuid": ""\n      },\n      "bunq_me": {\n        "name": "",\n        "service": "",\n        "type": "",\n        "value": ""\n      },\n      "country": "",\n      "display_name": "",\n      "iban": "",\n      "is_light": false,\n      "label_user": {\n        "avatar": {},\n        "country": "",\n        "display_name": "",\n        "public_nick_name": "",\n        "uuid": ""\n      },\n      "merchant_category_code": "",\n      "swift_account_number": "",\n      "swift_bic": "",\n      "transferwise_account_number": "",\n      "transferwise_bank_code": ""\n    },\n    "amount_inquired": {\n      "currency": "",\n      "value": ""\n    },\n    "description": "",\n    "invite_profile_name": "",\n    "merchant_available": [\n      {\n        "available": false,\n        "merchant_type": ""\n      }\n    ],\n    "redirect_url": "",\n    "status": "",\n    "uuid": ""\n  },\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({
  bunqme_tab_entry: {
    alias: {
      avatar: {
        anchor_uuid: '',
        image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
        style: '',
        uuid: ''
      },
      bunq_me: {name: '', service: '', type: '', value: ''},
      country: '',
      display_name: '',
      iban: '',
      is_light: false,
      label_user: {avatar: {}, country: '', display_name: '', public_nick_name: '', uuid: ''},
      merchant_category_code: '',
      swift_account_number: '',
      swift_bic: '',
      transferwise_account_number: '',
      transferwise_bank_code: ''
    },
    amount_inquired: {currency: '', value: ''},
    description: '',
    invite_profile_name: '',
    merchant_available: [{available: false, merchant_type: ''}],
    redirect_url: '',
    status: '',
    uuid: ''
  },
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    bunqme_tab_entry: {
      alias: {
        avatar: {
          anchor_uuid: '',
          image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
          style: '',
          uuid: ''
        },
        bunq_me: {name: '', service: '', type: '', value: ''},
        country: '',
        display_name: '',
        iban: '',
        is_light: false,
        label_user: {avatar: {}, country: '', display_name: '', public_nick_name: '', uuid: ''},
        merchant_category_code: '',
        swift_account_number: '',
        swift_bic: '',
        transferwise_account_number: '',
        transferwise_bank_code: ''
      },
      amount_inquired: {currency: '', value: ''},
      description: '',
      invite_profile_name: '',
      merchant_available: [{available: false, merchant_type: ''}],
      redirect_url: '',
      status: '',
      uuid: ''
    },
    status: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  bunqme_tab_entry: {
    alias: {
      avatar: {
        anchor_uuid: '',
        image: [
          {
            attachment_public_uuid: '',
            content_type: '',
            height: 0,
            width: 0
          }
        ],
        style: '',
        uuid: ''
      },
      bunq_me: {
        name: '',
        service: '',
        type: '',
        value: ''
      },
      country: '',
      display_name: '',
      iban: '',
      is_light: false,
      label_user: {
        avatar: {},
        country: '',
        display_name: '',
        public_nick_name: '',
        uuid: ''
      },
      merchant_category_code: '',
      swift_account_number: '',
      swift_bic: '',
      transferwise_account_number: '',
      transferwise_bank_code: ''
    },
    amount_inquired: {
      currency: '',
      value: ''
    },
    description: '',
    invite_profile_name: '',
    merchant_available: [
      {
        available: false,
        merchant_type: ''
      }
    ],
    redirect_url: '',
    status: '',
    uuid: ''
  },
  status: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    bunqme_tab_entry: {
      alias: {
        avatar: {
          anchor_uuid: '',
          image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
          style: '',
          uuid: ''
        },
        bunq_me: {name: '', service: '', type: '', value: ''},
        country: '',
        display_name: '',
        iban: '',
        is_light: false,
        label_user: {avatar: {}, country: '', display_name: '', public_nick_name: '', uuid: ''},
        merchant_category_code: '',
        swift_account_number: '',
        swift_bic: '',
        transferwise_account_number: '',
        transferwise_bank_code: ''
      },
      amount_inquired: {currency: '', value: ''},
      description: '',
      invite_profile_name: '',
      merchant_available: [{available: false, merchant_type: ''}],
      redirect_url: '',
      status: '',
      uuid: ''
    },
    status: ''
  }
};

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

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"bunqme_tab_entry":{"alias":{"avatar":{"anchor_uuid":"","image":[{"attachment_public_uuid":"","content_type":"","height":0,"width":0}],"style":"","uuid":""},"bunq_me":{"name":"","service":"","type":"","value":""},"country":"","display_name":"","iban":"","is_light":false,"label_user":{"avatar":{},"country":"","display_name":"","public_nick_name":"","uuid":""},"merchant_category_code":"","swift_account_number":"","swift_bic":"","transferwise_account_number":"","transferwise_bank_code":""},"amount_inquired":{"currency":"","value":""},"description":"","invite_profile_name":"","merchant_available":[{"available":false,"merchant_type":""}],"redirect_url":"","status":"","uuid":""},"status":""}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"bunqme_tab_entry": @{ @"alias": @{ @"avatar": @{ @"anchor_uuid": @"", @"image": @[ @{ @"attachment_public_uuid": @"", @"content_type": @"", @"height": @0, @"width": @0 } ], @"style": @"", @"uuid": @"" }, @"bunq_me": @{ @"name": @"", @"service": @"", @"type": @"", @"value": @"" }, @"country": @"", @"display_name": @"", @"iban": @"", @"is_light": @NO, @"label_user": @{ @"avatar": @{  }, @"country": @"", @"display_name": @"", @"public_nick_name": @"", @"uuid": @"" }, @"merchant_category_code": @"", @"swift_account_number": @"", @"swift_bic": @"", @"transferwise_account_number": @"", @"transferwise_bank_code": @"" }, @"amount_inquired": @{ @"currency": @"", @"value": @"" }, @"description": @"", @"invite_profile_name": @"", @"merchant_available": @[ @{ @"available": @NO, @"merchant_type": @"" } ], @"redirect_url": @"", @"status": @"", @"uuid": @"" },
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab",
  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([
    'bunqme_tab_entry' => [
        'alias' => [
                'avatar' => [
                                'anchor_uuid' => '',
                                'image' => [
                                                                [
                                                                                                                                'attachment_public_uuid' => '',
                                                                                                                                'content_type' => '',
                                                                                                                                'height' => 0,
                                                                                                                                'width' => 0
                                                                ]
                                ],
                                'style' => '',
                                'uuid' => ''
                ],
                'bunq_me' => [
                                'name' => '',
                                'service' => '',
                                'type' => '',
                                'value' => ''
                ],
                'country' => '',
                'display_name' => '',
                'iban' => '',
                'is_light' => null,
                'label_user' => [
                                'avatar' => [
                                                                
                                ],
                                'country' => '',
                                'display_name' => '',
                                'public_nick_name' => '',
                                'uuid' => ''
                ],
                'merchant_category_code' => '',
                'swift_account_number' => '',
                'swift_bic' => '',
                'transferwise_account_number' => '',
                'transferwise_bank_code' => ''
        ],
        'amount_inquired' => [
                'currency' => '',
                'value' => ''
        ],
        'description' => '',
        'invite_profile_name' => '',
        'merchant_available' => [
                [
                                'available' => null,
                                'merchant_type' => ''
                ]
        ],
        'redirect_url' => '',
        'status' => '',
        'uuid' => ''
    ],
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab', [
  'body' => '{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'bunqme_tab_entry' => [
    'alias' => [
        'avatar' => [
                'anchor_uuid' => '',
                'image' => [
                                [
                                                                'attachment_public_uuid' => '',
                                                                'content_type' => '',
                                                                'height' => 0,
                                                                'width' => 0
                                ]
                ],
                'style' => '',
                'uuid' => ''
        ],
        'bunq_me' => [
                'name' => '',
                'service' => '',
                'type' => '',
                'value' => ''
        ],
        'country' => '',
        'display_name' => '',
        'iban' => '',
        'is_light' => null,
        'label_user' => [
                'avatar' => [
                                
                ],
                'country' => '',
                'display_name' => '',
                'public_nick_name' => '',
                'uuid' => ''
        ],
        'merchant_category_code' => '',
        'swift_account_number' => '',
        'swift_bic' => '',
        'transferwise_account_number' => '',
        'transferwise_bank_code' => ''
    ],
    'amount_inquired' => [
        'currency' => '',
        'value' => ''
    ],
    'description' => '',
    'invite_profile_name' => '',
    'merchant_available' => [
        [
                'available' => null,
                'merchant_type' => ''
        ]
    ],
    'redirect_url' => '',
    'status' => '',
    'uuid' => ''
  ],
  'status' => ''
]));

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

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

append(json_encode([
  'bunqme_tab_entry' => [
    'alias' => [
        'avatar' => [
                'anchor_uuid' => '',
                'image' => [
                                [
                                                                'attachment_public_uuid' => '',
                                                                'content_type' => '',
                                                                'height' => 0,
                                                                'width' => 0
                                ]
                ],
                'style' => '',
                'uuid' => ''
        ],
        'bunq_me' => [
                'name' => '',
                'service' => '',
                'type' => '',
                'value' => ''
        ],
        'country' => '',
        'display_name' => '',
        'iban' => '',
        'is_light' => null,
        'label_user' => [
                'avatar' => [
                                
                ],
                'country' => '',
                'display_name' => '',
                'public_nick_name' => '',
                'uuid' => ''
        ],
        'merchant_category_code' => '',
        'swift_account_number' => '',
        'swift_bic' => '',
        'transferwise_account_number' => '',
        'transferwise_bank_code' => ''
    ],
    'amount_inquired' => [
        'currency' => '',
        'value' => ''
    ],
    'description' => '',
    'invite_profile_name' => '',
    'merchant_available' => [
        [
                'available' => null,
                'merchant_type' => ''
        ]
    ],
    'redirect_url' => '',
    'status' => '',
    'uuid' => ''
  ],
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}'

import http.client

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

payload = "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"

payload = {
    "bunqme_tab_entry": {
        "alias": {
            "avatar": {
                "anchor_uuid": "",
                "image": [
                    {
                        "attachment_public_uuid": "",
                        "content_type": "",
                        "height": 0,
                        "width": 0
                    }
                ],
                "style": "",
                "uuid": ""
            },
            "bunq_me": {
                "name": "",
                "service": "",
                "type": "",
                "value": ""
            },
            "country": "",
            "display_name": "",
            "iban": "",
            "is_light": False,
            "label_user": {
                "avatar": {},
                "country": "",
                "display_name": "",
                "public_nick_name": "",
                "uuid": ""
            },
            "merchant_category_code": "",
            "swift_account_number": "",
            "swift_bic": "",
            "transferwise_account_number": "",
            "transferwise_bank_code": ""
        },
        "amount_inquired": {
            "currency": "",
            "value": ""
        },
        "description": "",
        "invite_profile_name": "",
        "merchant_available": [
            {
                "available": False,
                "merchant_type": ""
            }
        ],
        "redirect_url": "",
        "status": "",
        "uuid": ""
    },
    "status": ""
}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"

payload <- "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")

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

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab";

    let payload = json!({
        "bunqme_tab_entry": json!({
            "alias": json!({
                "avatar": json!({
                    "anchor_uuid": "",
                    "image": (
                        json!({
                            "attachment_public_uuid": "",
                            "content_type": "",
                            "height": 0,
                            "width": 0
                        })
                    ),
                    "style": "",
                    "uuid": ""
                }),
                "bunq_me": json!({
                    "name": "",
                    "service": "",
                    "type": "",
                    "value": ""
                }),
                "country": "",
                "display_name": "",
                "iban": "",
                "is_light": false,
                "label_user": json!({
                    "avatar": json!({}),
                    "country": "",
                    "display_name": "",
                    "public_nick_name": "",
                    "uuid": ""
                }),
                "merchant_category_code": "",
                "swift_account_number": "",
                "swift_bic": "",
                "transferwise_account_number": "",
                "transferwise_bank_code": ""
            }),
            "amount_inquired": json!({
                "currency": "",
                "value": ""
            }),
            "description": "",
            "invite_profile_name": "",
            "merchant_available": (
                json!({
                    "available": false,
                    "merchant_type": ""
                })
            ),
            "redirect_url": "",
            "status": "",
            "uuid": ""
        }),
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}' |  \
  http POST {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "bunqme_tab_entry": {\n    "alias": {\n      "avatar": {\n        "anchor_uuid": "",\n        "image": [\n          {\n            "attachment_public_uuid": "",\n            "content_type": "",\n            "height": 0,\n            "width": 0\n          }\n        ],\n        "style": "",\n        "uuid": ""\n      },\n      "bunq_me": {\n        "name": "",\n        "service": "",\n        "type": "",\n        "value": ""\n      },\n      "country": "",\n      "display_name": "",\n      "iban": "",\n      "is_light": false,\n      "label_user": {\n        "avatar": {},\n        "country": "",\n        "display_name": "",\n        "public_nick_name": "",\n        "uuid": ""\n      },\n      "merchant_category_code": "",\n      "swift_account_number": "",\n      "swift_bic": "",\n      "transferwise_account_number": "",\n      "transferwise_bank_code": ""\n    },\n    "amount_inquired": {\n      "currency": "",\n      "value": ""\n    },\n    "description": "",\n    "invite_profile_name": "",\n    "merchant_available": [\n      {\n        "available": false,\n        "merchant_type": ""\n      }\n    ],\n    "redirect_url": "",\n    "status": "",\n    "uuid": ""\n  },\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [
  "bunqme_tab_entry": [
    "alias": [
      "avatar": [
        "anchor_uuid": "",
        "image": [
          [
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          ]
        ],
        "style": "",
        "uuid": ""
      ],
      "bunq_me": [
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      ],
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": [
        "avatar": [],
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      ],
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    ],
    "amount_inquired": [
      "currency": "",
      "value": ""
    ],
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      [
        "available": false,
        "merchant_type": ""
      ]
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  ],
  "status": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab" {:headers {:user-agent ""
                                                                                                                  :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab")! 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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId" {:headers {:user-agent ""
                                                                                                                          :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId" {:headers {:user-agent ""
                                                                                                                          :x-bunq-client-authentication ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:bunqme_tab_entry {:alias {:avatar {:anchor_uuid ""
                                                                                                                                                                  :image [{:attachment_public_uuid ""
                                                                                                                                                                           :content_type ""
                                                                                                                                                                           :height 0
                                                                                                                                                                           :width 0}]
                                                                                                                                                                  :style ""
                                                                                                                                                                  :uuid ""}
                                                                                                                                                         :bunq_me {:name ""
                                                                                                                                                                   :service ""
                                                                                                                                                                   :type ""
                                                                                                                                                                   :value ""}
                                                                                                                                                         :country ""
                                                                                                                                                         :display_name ""
                                                                                                                                                         :iban ""
                                                                                                                                                         :is_light false
                                                                                                                                                         :label_user {:avatar {}
                                                                                                                                                                      :country ""
                                                                                                                                                                      :display_name ""
                                                                                                                                                                      :public_nick_name ""
                                                                                                                                                                      :uuid ""}
                                                                                                                                                         :merchant_category_code ""
                                                                                                                                                         :swift_account_number ""
                                                                                                                                                         :swift_bic ""
                                                                                                                                                         :transferwise_account_number ""
                                                                                                                                                         :transferwise_bank_code ""}
                                                                                                                                                 :amount_inquired {:currency ""
                                                                                                                                                                   :value ""}
                                                                                                                                                 :description ""
                                                                                                                                                 :invite_profile_name ""
                                                                                                                                                 :merchant_available [{:available false
                                                                                                                                                                       :merchant_type ""}]
                                                                                                                                                 :redirect_url ""
                                                                                                                                                 :status ""
                                                                                                                                                 :uuid ""}
                                                                                                                              :status ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId");
var request = new RestRequest("", Method.Put);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"

	payload := strings.NewReader("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 1154

{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  bunqme_tab_entry: {
    alias: {
      avatar: {
        anchor_uuid: '',
        image: [
          {
            attachment_public_uuid: '',
            content_type: '',
            height: 0,
            width: 0
          }
        ],
        style: '',
        uuid: ''
      },
      bunq_me: {
        name: '',
        service: '',
        type: '',
        value: ''
      },
      country: '',
      display_name: '',
      iban: '',
      is_light: false,
      label_user: {
        avatar: {},
        country: '',
        display_name: '',
        public_nick_name: '',
        uuid: ''
      },
      merchant_category_code: '',
      swift_account_number: '',
      swift_bic: '',
      transferwise_account_number: '',
      transferwise_bank_code: ''
    },
    amount_inquired: {
      currency: '',
      value: ''
    },
    description: '',
    invite_profile_name: '',
    merchant_available: [
      {
        available: false,
        merchant_type: ''
      }
    ],
    redirect_url: '',
    status: '',
    uuid: ''
  },
  status: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    bunqme_tab_entry: {
      alias: {
        avatar: {
          anchor_uuid: '',
          image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
          style: '',
          uuid: ''
        },
        bunq_me: {name: '', service: '', type: '', value: ''},
        country: '',
        display_name: '',
        iban: '',
        is_light: false,
        label_user: {avatar: {}, country: '', display_name: '', public_nick_name: '', uuid: ''},
        merchant_category_code: '',
        swift_account_number: '',
        swift_bic: '',
        transferwise_account_number: '',
        transferwise_bank_code: ''
      },
      amount_inquired: {currency: '', value: ''},
      description: '',
      invite_profile_name: '',
      merchant_available: [{available: false, merchant_type: ''}],
      redirect_url: '',
      status: '',
      uuid: ''
    },
    status: ''
  }
};

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"bunqme_tab_entry":{"alias":{"avatar":{"anchor_uuid":"","image":[{"attachment_public_uuid":"","content_type":"","height":0,"width":0}],"style":"","uuid":""},"bunq_me":{"name":"","service":"","type":"","value":""},"country":"","display_name":"","iban":"","is_light":false,"label_user":{"avatar":{},"country":"","display_name":"","public_nick_name":"","uuid":""},"merchant_category_code":"","swift_account_number":"","swift_bic":"","transferwise_account_number":"","transferwise_bank_code":""},"amount_inquired":{"currency":"","value":""},"description":"","invite_profile_name":"","merchant_available":[{"available":false,"merchant_type":""}],"redirect_url":"","status":"","uuid":""},"status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "bunqme_tab_entry": {\n    "alias": {\n      "avatar": {\n        "anchor_uuid": "",\n        "image": [\n          {\n            "attachment_public_uuid": "",\n            "content_type": "",\n            "height": 0,\n            "width": 0\n          }\n        ],\n        "style": "",\n        "uuid": ""\n      },\n      "bunq_me": {\n        "name": "",\n        "service": "",\n        "type": "",\n        "value": ""\n      },\n      "country": "",\n      "display_name": "",\n      "iban": "",\n      "is_light": false,\n      "label_user": {\n        "avatar": {},\n        "country": "",\n        "display_name": "",\n        "public_nick_name": "",\n        "uuid": ""\n      },\n      "merchant_category_code": "",\n      "swift_account_number": "",\n      "swift_bic": "",\n      "transferwise_account_number": "",\n      "transferwise_bank_code": ""\n    },\n    "amount_inquired": {\n      "currency": "",\n      "value": ""\n    },\n    "description": "",\n    "invite_profile_name": "",\n    "merchant_available": [\n      {\n        "available": false,\n        "merchant_type": ""\n      }\n    ],\n    "redirect_url": "",\n    "status": "",\n    "uuid": ""\n  },\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({
  bunqme_tab_entry: {
    alias: {
      avatar: {
        anchor_uuid: '',
        image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
        style: '',
        uuid: ''
      },
      bunq_me: {name: '', service: '', type: '', value: ''},
      country: '',
      display_name: '',
      iban: '',
      is_light: false,
      label_user: {avatar: {}, country: '', display_name: '', public_nick_name: '', uuid: ''},
      merchant_category_code: '',
      swift_account_number: '',
      swift_bic: '',
      transferwise_account_number: '',
      transferwise_bank_code: ''
    },
    amount_inquired: {currency: '', value: ''},
    description: '',
    invite_profile_name: '',
    merchant_available: [{available: false, merchant_type: ''}],
    redirect_url: '',
    status: '',
    uuid: ''
  },
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    bunqme_tab_entry: {
      alias: {
        avatar: {
          anchor_uuid: '',
          image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
          style: '',
          uuid: ''
        },
        bunq_me: {name: '', service: '', type: '', value: ''},
        country: '',
        display_name: '',
        iban: '',
        is_light: false,
        label_user: {avatar: {}, country: '', display_name: '', public_nick_name: '', uuid: ''},
        merchant_category_code: '',
        swift_account_number: '',
        swift_bic: '',
        transferwise_account_number: '',
        transferwise_bank_code: ''
      },
      amount_inquired: {currency: '', value: ''},
      description: '',
      invite_profile_name: '',
      merchant_available: [{available: false, merchant_type: ''}],
      redirect_url: '',
      status: '',
      uuid: ''
    },
    status: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  bunqme_tab_entry: {
    alias: {
      avatar: {
        anchor_uuid: '',
        image: [
          {
            attachment_public_uuid: '',
            content_type: '',
            height: 0,
            width: 0
          }
        ],
        style: '',
        uuid: ''
      },
      bunq_me: {
        name: '',
        service: '',
        type: '',
        value: ''
      },
      country: '',
      display_name: '',
      iban: '',
      is_light: false,
      label_user: {
        avatar: {},
        country: '',
        display_name: '',
        public_nick_name: '',
        uuid: ''
      },
      merchant_category_code: '',
      swift_account_number: '',
      swift_bic: '',
      transferwise_account_number: '',
      transferwise_bank_code: ''
    },
    amount_inquired: {
      currency: '',
      value: ''
    },
    description: '',
    invite_profile_name: '',
    merchant_available: [
      {
        available: false,
        merchant_type: ''
      }
    ],
    redirect_url: '',
    status: '',
    uuid: ''
  },
  status: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    bunqme_tab_entry: {
      alias: {
        avatar: {
          anchor_uuid: '',
          image: [{attachment_public_uuid: '', content_type: '', height: 0, width: 0}],
          style: '',
          uuid: ''
        },
        bunq_me: {name: '', service: '', type: '', value: ''},
        country: '',
        display_name: '',
        iban: '',
        is_light: false,
        label_user: {avatar: {}, country: '', display_name: '', public_nick_name: '', uuid: ''},
        merchant_category_code: '',
        swift_account_number: '',
        swift_bic: '',
        transferwise_account_number: '',
        transferwise_bank_code: ''
      },
      amount_inquired: {currency: '', value: ''},
      description: '',
      invite_profile_name: '',
      merchant_available: [{available: false, merchant_type: ''}],
      redirect_url: '',
      status: '',
      uuid: ''
    },
    status: ''
  }
};

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

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"bunqme_tab_entry":{"alias":{"avatar":{"anchor_uuid":"","image":[{"attachment_public_uuid":"","content_type":"","height":0,"width":0}],"style":"","uuid":""},"bunq_me":{"name":"","service":"","type":"","value":""},"country":"","display_name":"","iban":"","is_light":false,"label_user":{"avatar":{},"country":"","display_name":"","public_nick_name":"","uuid":""},"merchant_category_code":"","swift_account_number":"","swift_bic":"","transferwise_account_number":"","transferwise_bank_code":""},"amount_inquired":{"currency":"","value":""},"description":"","invite_profile_name":"","merchant_available":[{"available":false,"merchant_type":""}],"redirect_url":"","status":"","uuid":""},"status":""}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"bunqme_tab_entry": @{ @"alias": @{ @"avatar": @{ @"anchor_uuid": @"", @"image": @[ @{ @"attachment_public_uuid": @"", @"content_type": @"", @"height": @0, @"width": @0 } ], @"style": @"", @"uuid": @"" }, @"bunq_me": @{ @"name": @"", @"service": @"", @"type": @"", @"value": @"" }, @"country": @"", @"display_name": @"", @"iban": @"", @"is_light": @NO, @"label_user": @{ @"avatar": @{  }, @"country": @"", @"display_name": @"", @"public_nick_name": @"", @"uuid": @"" }, @"merchant_category_code": @"", @"swift_account_number": @"", @"swift_bic": @"", @"transferwise_account_number": @"", @"transferwise_bank_code": @"" }, @"amount_inquired": @{ @"currency": @"", @"value": @"" }, @"description": @"", @"invite_profile_name": @"", @"merchant_available": @[ @{ @"available": @NO, @"merchant_type": @"" } ], @"redirect_url": @"", @"status": @"", @"uuid": @"" },
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId",
  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([
    'bunqme_tab_entry' => [
        'alias' => [
                'avatar' => [
                                'anchor_uuid' => '',
                                'image' => [
                                                                [
                                                                                                                                'attachment_public_uuid' => '',
                                                                                                                                'content_type' => '',
                                                                                                                                'height' => 0,
                                                                                                                                'width' => 0
                                                                ]
                                ],
                                'style' => '',
                                'uuid' => ''
                ],
                'bunq_me' => [
                                'name' => '',
                                'service' => '',
                                'type' => '',
                                'value' => ''
                ],
                'country' => '',
                'display_name' => '',
                'iban' => '',
                'is_light' => null,
                'label_user' => [
                                'avatar' => [
                                                                
                                ],
                                'country' => '',
                                'display_name' => '',
                                'public_nick_name' => '',
                                'uuid' => ''
                ],
                'merchant_category_code' => '',
                'swift_account_number' => '',
                'swift_bic' => '',
                'transferwise_account_number' => '',
                'transferwise_bank_code' => ''
        ],
        'amount_inquired' => [
                'currency' => '',
                'value' => ''
        ],
        'description' => '',
        'invite_profile_name' => '',
        'merchant_available' => [
                [
                                'available' => null,
                                'merchant_type' => ''
                ]
        ],
        'redirect_url' => '',
        'status' => '',
        'uuid' => ''
    ],
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId', [
  'body' => '{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'bunqme_tab_entry' => [
    'alias' => [
        'avatar' => [
                'anchor_uuid' => '',
                'image' => [
                                [
                                                                'attachment_public_uuid' => '',
                                                                'content_type' => '',
                                                                'height' => 0,
                                                                'width' => 0
                                ]
                ],
                'style' => '',
                'uuid' => ''
        ],
        'bunq_me' => [
                'name' => '',
                'service' => '',
                'type' => '',
                'value' => ''
        ],
        'country' => '',
        'display_name' => '',
        'iban' => '',
        'is_light' => null,
        'label_user' => [
                'avatar' => [
                                
                ],
                'country' => '',
                'display_name' => '',
                'public_nick_name' => '',
                'uuid' => ''
        ],
        'merchant_category_code' => '',
        'swift_account_number' => '',
        'swift_bic' => '',
        'transferwise_account_number' => '',
        'transferwise_bank_code' => ''
    ],
    'amount_inquired' => [
        'currency' => '',
        'value' => ''
    ],
    'description' => '',
    'invite_profile_name' => '',
    'merchant_available' => [
        [
                'available' => null,
                'merchant_type' => ''
        ]
    ],
    'redirect_url' => '',
    'status' => '',
    'uuid' => ''
  ],
  'status' => ''
]));

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

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

append(json_encode([
  'bunqme_tab_entry' => [
    'alias' => [
        'avatar' => [
                'anchor_uuid' => '',
                'image' => [
                                [
                                                                'attachment_public_uuid' => '',
                                                                'content_type' => '',
                                                                'height' => 0,
                                                                'width' => 0
                                ]
                ],
                'style' => '',
                'uuid' => ''
        ],
        'bunq_me' => [
                'name' => '',
                'service' => '',
                'type' => '',
                'value' => ''
        ],
        'country' => '',
        'display_name' => '',
        'iban' => '',
        'is_light' => null,
        'label_user' => [
                'avatar' => [
                                
                ],
                'country' => '',
                'display_name' => '',
                'public_nick_name' => '',
                'uuid' => ''
        ],
        'merchant_category_code' => '',
        'swift_account_number' => '',
        'swift_bic' => '',
        'transferwise_account_number' => '',
        'transferwise_bank_code' => ''
    ],
    'amount_inquired' => [
        'currency' => '',
        'value' => ''
    ],
    'description' => '',
    'invite_profile_name' => '',
    'merchant_available' => [
        [
                'available' => null,
                'merchant_type' => ''
        ]
    ],
    'redirect_url' => '',
    'status' => '',
    'uuid' => ''
  ],
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}'

import http.client

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

payload = "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"

payload = {
    "bunqme_tab_entry": {
        "alias": {
            "avatar": {
                "anchor_uuid": "",
                "image": [
                    {
                        "attachment_public_uuid": "",
                        "content_type": "",
                        "height": 0,
                        "width": 0
                    }
                ],
                "style": "",
                "uuid": ""
            },
            "bunq_me": {
                "name": "",
                "service": "",
                "type": "",
                "value": ""
            },
            "country": "",
            "display_name": "",
            "iban": "",
            "is_light": False,
            "label_user": {
                "avatar": {},
                "country": "",
                "display_name": "",
                "public_nick_name": "",
                "uuid": ""
            },
            "merchant_category_code": "",
            "swift_account_number": "",
            "swift_bic": "",
            "transferwise_account_number": "",
            "transferwise_bank_code": ""
        },
        "amount_inquired": {
            "currency": "",
            "value": ""
        },
        "description": "",
        "invite_profile_name": "",
        "merchant_available": [
            {
                "available": False,
                "merchant_type": ""
            }
        ],
        "redirect_url": "",
        "status": "",
        "uuid": ""
    },
    "status": ""
}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId"

payload <- "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")

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

request = Net::HTTP::Put.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"bunqme_tab_entry\": {\n    \"alias\": {\n      \"avatar\": {\n        \"anchor_uuid\": \"\",\n        \"image\": [\n          {\n            \"attachment_public_uuid\": \"\",\n            \"content_type\": \"\",\n            \"height\": 0,\n            \"width\": 0\n          }\n        ],\n        \"style\": \"\",\n        \"uuid\": \"\"\n      },\n      \"bunq_me\": {\n        \"name\": \"\",\n        \"service\": \"\",\n        \"type\": \"\",\n        \"value\": \"\"\n      },\n      \"country\": \"\",\n      \"display_name\": \"\",\n      \"iban\": \"\",\n      \"is_light\": false,\n      \"label_user\": {\n        \"avatar\": {},\n        \"country\": \"\",\n        \"display_name\": \"\",\n        \"public_nick_name\": \"\",\n        \"uuid\": \"\"\n      },\n      \"merchant_category_code\": \"\",\n      \"swift_account_number\": \"\",\n      \"swift_bic\": \"\",\n      \"transferwise_account_number\": \"\",\n      \"transferwise_bank_code\": \"\"\n    },\n    \"amount_inquired\": {\n      \"currency\": \"\",\n      \"value\": \"\"\n    },\n    \"description\": \"\",\n    \"invite_profile_name\": \"\",\n    \"merchant_available\": [\n      {\n        \"available\": false,\n        \"merchant_type\": \"\"\n      }\n    ],\n    \"redirect_url\": \"\",\n    \"status\": \"\",\n    \"uuid\": \"\"\n  },\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId";

    let payload = json!({
        "bunqme_tab_entry": json!({
            "alias": json!({
                "avatar": json!({
                    "anchor_uuid": "",
                    "image": (
                        json!({
                            "attachment_public_uuid": "",
                            "content_type": "",
                            "height": 0,
                            "width": 0
                        })
                    ),
                    "style": "",
                    "uuid": ""
                }),
                "bunq_me": json!({
                    "name": "",
                    "service": "",
                    "type": "",
                    "value": ""
                }),
                "country": "",
                "display_name": "",
                "iban": "",
                "is_light": false,
                "label_user": json!({
                    "avatar": json!({}),
                    "country": "",
                    "display_name": "",
                    "public_nick_name": "",
                    "uuid": ""
                }),
                "merchant_category_code": "",
                "swift_account_number": "",
                "swift_bic": "",
                "transferwise_account_number": "",
                "transferwise_bank_code": ""
            }),
            "amount_inquired": json!({
                "currency": "",
                "value": ""
            }),
            "description": "",
            "invite_profile_name": "",
            "merchant_available": (
                json!({
                    "available": false,
                    "merchant_type": ""
                })
            ),
            "redirect_url": "",
            "status": "",
            "uuid": ""
        }),
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".parse().unwrap());
    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 '{
  "bunqme_tab_entry": {
    "alias": {
      "avatar": {
        "anchor_uuid": "",
        "image": [
          {
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          }
        ],
        "style": "",
        "uuid": ""
      },
      "bunq_me": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      },
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": {
        "avatar": {},
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      },
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    },
    "amount_inquired": {
      "currency": "",
      "value": ""
    },
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      {
        "available": false,
        "merchant_type": ""
      }
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  },
  "status": ""
}' |  \
  http PUT {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method PUT \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "bunqme_tab_entry": {\n    "alias": {\n      "avatar": {\n        "anchor_uuid": "",\n        "image": [\n          {\n            "attachment_public_uuid": "",\n            "content_type": "",\n            "height": 0,\n            "width": 0\n          }\n        ],\n        "style": "",\n        "uuid": ""\n      },\n      "bunq_me": {\n        "name": "",\n        "service": "",\n        "type": "",\n        "value": ""\n      },\n      "country": "",\n      "display_name": "",\n      "iban": "",\n      "is_light": false,\n      "label_user": {\n        "avatar": {},\n        "country": "",\n        "display_name": "",\n        "public_nick_name": "",\n        "uuid": ""\n      },\n      "merchant_category_code": "",\n      "swift_account_number": "",\n      "swift_bic": "",\n      "transferwise_account_number": "",\n      "transferwise_bank_code": ""\n    },\n    "amount_inquired": {\n      "currency": "",\n      "value": ""\n    },\n    "description": "",\n    "invite_profile_name": "",\n    "merchant_available": [\n      {\n        "available": false,\n        "merchant_type": ""\n      }\n    ],\n    "redirect_url": "",\n    "status": "",\n    "uuid": ""\n  },\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [
  "bunqme_tab_entry": [
    "alias": [
      "avatar": [
        "anchor_uuid": "",
        "image": [
          [
            "attachment_public_uuid": "",
            "content_type": "",
            "height": 0,
            "width": 0
          ]
        ],
        "style": "",
        "uuid": ""
      ],
      "bunq_me": [
        "name": "",
        "service": "",
        "type": "",
        "value": ""
      ],
      "country": "",
      "display_name": "",
      "iban": "",
      "is_light": false,
      "label_user": [
        "avatar": [],
        "country": "",
        "display_name": "",
        "public_nick_name": "",
        "uuid": ""
      ],
      "merchant_category_code": "",
      "swift_account_number": "",
      "swift_bic": "",
      "transferwise_account_number": "",
      "transferwise_bank_code": ""
    ],
    "amount_inquired": [
      "currency": "",
      "value": ""
    ],
    "description": "",
    "invite_profile_name": "",
    "merchant_available": [
      [
        "available": false,
        "merchant_type": ""
      ]
    ],
    "redirect_url": "",
    "status": "",
    "uuid": ""
  ],
  "status": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab/:itemId")! 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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId" {:headers {:user-agent ""
                                                                                                                                          :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/bunqme-tab-result-response/:itemId")! 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}}/user/:userID/oauth-client/:oauth-clientID/callback-url");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url" {:headers {:user-agent ""
                                                                                                             :x-bunq-client-authentication ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:url ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"url\": \"\"\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}}/user/:userID/oauth-client/:oauth-clientID/callback-url"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"url\": \"\"\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}}/user/:userID/oauth-client/:oauth-clientID/callback-url");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"

	payload := strings.NewReader("{\n  \"url\": \"\"\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/oauth-client/:oauth-clientID/callback-url HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"url\": \"\"\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  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  url: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {url: ''}
};

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"url":""}'
};

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "url": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/oauth-client/:oauth-clientID/callback-url',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({url: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {url: ''},
  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}}/user/:userID/oauth-client/:oauth-clientID/callback-url');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  url: ''
});

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {url: ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"url":""}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"url": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"]
                                                       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}}/user/:userID/oauth-client/:oauth-clientID/callback-url" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"url\": \"\"\n}" in

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

 "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url",
  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([
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url', [
  'body' => '{
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "url": ""
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "url": ""
}'

import http.client

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

payload = "{\n  \"url\": \"\"\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"

payload = { "url": "" }
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"

payload <- "{\n  \"url\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")

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

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"url\": \"\"\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/user/:userID/oauth-client/:oauth-clientID/callback-url') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url";

    let payload = json!({"url": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "url": ""
}' |  \
  http POST {{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = ["url": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")! 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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId" {:headers {:user-agent ""
                                                                                                                       :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

DELETE /baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .delete(null)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId';
const options = {
  method: 'DELETE',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  method: 'DELETE',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .delete(null)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId';
const options = {
  method: 'DELETE',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"]
                                                       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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("DELETE", "/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"

response <- VERB("DELETE", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")

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

request = Net::HTTP::Delete.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method DELETE \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")! 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}}/user/:userID/oauth-client/:oauth-clientID/callback-url");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url" {:headers {:user-agent ""
                                                                                                            :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/oauth-client/:oauth-clientID/callback-url")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/oauth-client/:oauth-clientID/callback-url');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"]
                                                       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}}/user/:userID/oauth-client/:oauth-clientID/callback-url" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/oauth-client/:oauth-clientID/callback-url \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url")! 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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId" {:headers {:user-agent ""
                                                                                                                    :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"]
                                                       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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId" {:headers {:user-agent ""
                                                                                                                    :x-bunq-client-authentication ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:url ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"url\": \"\"\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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"url\": \"\"\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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId");
var request = new RestRequest("", Method.Put);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"

	payload := strings.NewReader("{\n  \"url\": \"\"\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"url\": \"\"\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  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  url: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {url: ''}
};

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"url":""}'
};

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "url": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({url: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {url: ''},
  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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  url: ''
});

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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {url: ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"url":""}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"url": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"]
                                                       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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"url\": \"\"\n}" in

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

 "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId",
  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([
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId', [
  'body' => '{
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "url": ""
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "url": ""
}'

import http.client

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

payload = "{\n  \"url\": \"\"\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"

payload = { "url": "" }
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId"

payload <- "{\n  \"url\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")

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

request = Net::HTTP::Put.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"url\": \"\"\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/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"url\": \"\"\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}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId";

    let payload = json!({"url": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".parse().unwrap());
    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 '{
  "url": ""
}' |  \
  http PUT {{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method PUT \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = ["url": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/oauth-client/:oauth-clientID/callback-url/:itemId")! 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}}/user/:userID/card");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/card" {:headers {:user-agent ""
                                                                       :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/card"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/card"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/card");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/card"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/card HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/card")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/card"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/card")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/card")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/card');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/card',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/card';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/card',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/card")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/card',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/card',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/card');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/card',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/card';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/card"]
                                                       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}}/user/:userID/card" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/card",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/card', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/card');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/card');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/card' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/card' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/card", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/card"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/card"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/card")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/card') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/card \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/card

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/card/:itemId" {:headers {:user-agent ""
                                                                               :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/card/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/card/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/card/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/card/:itemId"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/card/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/card/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/card/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/card/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/card/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/card/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/card/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/card/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/card/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/card/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/card/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/card/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/card/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/card/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/card/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/card/:itemId"]
                                                       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}}/user/:userID/card/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/card/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/:userID/card/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/card/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/user/:userID/card/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/card/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/card/:itemId' -Method GET -Headers $headers

import http.client

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

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/card/:itemId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/card/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/card/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/card/:itemId")

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

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/user/:userID/card/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/card/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/card/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/card/:itemId")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/card/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/user/:userID/card/:itemId" {:headers {:user-agent ""
                                                                               :x-bunq-client-authentication ""}
                                                                     :content-type :json
                                                                     :form-params {:activation_code ""
                                                                                   :card_limit {:currency ""
                                                                                                :value ""}
                                                                                   :card_limit_atm {}
                                                                                   :country_permission [{:country ""
                                                                                                         :expiry_time ""
                                                                                                         :id 0}]
                                                                                   :monetary_account_id_fallback 0
                                                                                   :order_status ""
                                                                                   :pin_code ""
                                                                                   :pin_code_assignment [{:monetary_account_id 0
                                                                                                          :pin_code ""
                                                                                                          :routing_type ""
                                                                                                          :type ""}]
                                                                                   :primary_account_numbers [{:description ""
                                                                                                              :four_digit ""
                                                                                                              :id 0
                                                                                                              :monetary_account_id 0
                                                                                                              :status ""
                                                                                                              :uuid ""}]
                                                                                   :status ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/card/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\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}}/user/:userID/card/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/card/:itemId");
var request = new RestRequest("", Method.Put);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/card/:itemId"

	payload := strings.NewReader("{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/card/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 628

{
  "activation_code": "",
  "card_limit": {
    "currency": "",
    "value": ""
  },
  "card_limit_atm": {},
  "country_permission": [
    {
      "country": "",
      "expiry_time": "",
      "id": 0
    }
  ],
  "monetary_account_id_fallback": 0,
  "order_status": "",
  "pin_code": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "primary_account_numbers": [
    {
      "description": "",
      "four_digit": "",
      "id": 0,
      "monetary_account_id": 0,
      "status": "",
      "uuid": ""
    }
  ],
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/user/:userID/card/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/card/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/card/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/user/:userID/card/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  activation_code: '',
  card_limit: {
    currency: '',
    value: ''
  },
  card_limit_atm: {},
  country_permission: [
    {
      country: '',
      expiry_time: '',
      id: 0
    }
  ],
  monetary_account_id_fallback: 0,
  order_status: '',
  pin_code: '',
  pin_code_assignment: [
    {
      monetary_account_id: 0,
      pin_code: '',
      routing_type: '',
      type: ''
    }
  ],
  primary_account_numbers: [
    {
      description: '',
      four_digit: '',
      id: 0,
      monetary_account_id: 0,
      status: '',
      uuid: ''
    }
  ],
  status: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/user/:userID/card/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/card/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    activation_code: '',
    card_limit: {currency: '', value: ''},
    card_limit_atm: {},
    country_permission: [{country: '', expiry_time: '', id: 0}],
    monetary_account_id_fallback: 0,
    order_status: '',
    pin_code: '',
    pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
    primary_account_numbers: [
      {
        description: '',
        four_digit: '',
        id: 0,
        monetary_account_id: 0,
        status: '',
        uuid: ''
      }
    ],
    status: ''
  }
};

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

const url = '{{baseUrl}}/user/:userID/card/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"activation_code":"","card_limit":{"currency":"","value":""},"card_limit_atm":{},"country_permission":[{"country":"","expiry_time":"","id":0}],"monetary_account_id_fallback":0,"order_status":"","pin_code":"","pin_code_assignment":[{"monetary_account_id":0,"pin_code":"","routing_type":"","type":""}],"primary_account_numbers":[{"description":"","four_digit":"","id":0,"monetary_account_id":0,"status":"","uuid":""}],"status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/card/:itemId',
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "activation_code": "",\n  "card_limit": {\n    "currency": "",\n    "value": ""\n  },\n  "card_limit_atm": {},\n  "country_permission": [\n    {\n      "country": "",\n      "expiry_time": "",\n      "id": 0\n    }\n  ],\n  "monetary_account_id_fallback": 0,\n  "order_status": "",\n  "pin_code": "",\n  "pin_code_assignment": [\n    {\n      "monetary_account_id": 0,\n      "pin_code": "",\n      "routing_type": "",\n      "type": ""\n    }\n  ],\n  "primary_account_numbers": [\n    {\n      "description": "",\n      "four_digit": "",\n      "id": 0,\n      "monetary_account_id": 0,\n      "status": "",\n      "uuid": ""\n    }\n  ],\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/card/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/card/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({
  activation_code: '',
  card_limit: {currency: '', value: ''},
  card_limit_atm: {},
  country_permission: [{country: '', expiry_time: '', id: 0}],
  monetary_account_id_fallback: 0,
  order_status: '',
  pin_code: '',
  pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
  primary_account_numbers: [
    {
      description: '',
      four_digit: '',
      id: 0,
      monetary_account_id: 0,
      status: '',
      uuid: ''
    }
  ],
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/card/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    activation_code: '',
    card_limit: {currency: '', value: ''},
    card_limit_atm: {},
    country_permission: [{country: '', expiry_time: '', id: 0}],
    monetary_account_id_fallback: 0,
    order_status: '',
    pin_code: '',
    pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
    primary_account_numbers: [
      {
        description: '',
        four_digit: '',
        id: 0,
        monetary_account_id: 0,
        status: '',
        uuid: ''
      }
    ],
    status: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/user/:userID/card/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  activation_code: '',
  card_limit: {
    currency: '',
    value: ''
  },
  card_limit_atm: {},
  country_permission: [
    {
      country: '',
      expiry_time: '',
      id: 0
    }
  ],
  monetary_account_id_fallback: 0,
  order_status: '',
  pin_code: '',
  pin_code_assignment: [
    {
      monetary_account_id: 0,
      pin_code: '',
      routing_type: '',
      type: ''
    }
  ],
  primary_account_numbers: [
    {
      description: '',
      four_digit: '',
      id: 0,
      monetary_account_id: 0,
      status: '',
      uuid: ''
    }
  ],
  status: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/card/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    activation_code: '',
    card_limit: {currency: '', value: ''},
    card_limit_atm: {},
    country_permission: [{country: '', expiry_time: '', id: 0}],
    monetary_account_id_fallback: 0,
    order_status: '',
    pin_code: '',
    pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
    primary_account_numbers: [
      {
        description: '',
        four_digit: '',
        id: 0,
        monetary_account_id: 0,
        status: '',
        uuid: ''
      }
    ],
    status: ''
  }
};

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

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

const url = '{{baseUrl}}/user/:userID/card/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"activation_code":"","card_limit":{"currency":"","value":""},"card_limit_atm":{},"country_permission":[{"country":"","expiry_time":"","id":0}],"monetary_account_id_fallback":0,"order_status":"","pin_code":"","pin_code_assignment":[{"monetary_account_id":0,"pin_code":"","routing_type":"","type":""}],"primary_account_numbers":[{"description":"","four_digit":"","id":0,"monetary_account_id":0,"status":"","uuid":""}],"status":""}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"activation_code": @"",
                              @"card_limit": @{ @"currency": @"", @"value": @"" },
                              @"card_limit_atm": @{  },
                              @"country_permission": @[ @{ @"country": @"", @"expiry_time": @"", @"id": @0 } ],
                              @"monetary_account_id_fallback": @0,
                              @"order_status": @"",
                              @"pin_code": @"",
                              @"pin_code_assignment": @[ @{ @"monetary_account_id": @0, @"pin_code": @"", @"routing_type": @"", @"type": @"" } ],
                              @"primary_account_numbers": @[ @{ @"description": @"", @"four_digit": @"", @"id": @0, @"monetary_account_id": @0, @"status": @"", @"uuid": @"" } ],
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/card/:itemId"]
                                                       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}}/user/:userID/card/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/user/:userID/card/:itemId",
  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([
    'activation_code' => '',
    'card_limit' => [
        'currency' => '',
        'value' => ''
    ],
    'card_limit_atm' => [
        
    ],
    'country_permission' => [
        [
                'country' => '',
                'expiry_time' => '',
                'id' => 0
        ]
    ],
    'monetary_account_id_fallback' => 0,
    'order_status' => '',
    'pin_code' => '',
    'pin_code_assignment' => [
        [
                'monetary_account_id' => 0,
                'pin_code' => '',
                'routing_type' => '',
                'type' => ''
        ]
    ],
    'primary_account_numbers' => [
        [
                'description' => '',
                'four_digit' => '',
                'id' => 0,
                'monetary_account_id' => 0,
                'status' => '',
                'uuid' => ''
        ]
    ],
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/user/:userID/card/:itemId', [
  'body' => '{
  "activation_code": "",
  "card_limit": {
    "currency": "",
    "value": ""
  },
  "card_limit_atm": {},
  "country_permission": [
    {
      "country": "",
      "expiry_time": "",
      "id": 0
    }
  ],
  "monetary_account_id_fallback": 0,
  "order_status": "",
  "pin_code": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "primary_account_numbers": [
    {
      "description": "",
      "four_digit": "",
      "id": 0,
      "monetary_account_id": 0,
      "status": "",
      "uuid": ""
    }
  ],
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/card/:itemId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'activation_code' => '',
  'card_limit' => [
    'currency' => '',
    'value' => ''
  ],
  'card_limit_atm' => [
    
  ],
  'country_permission' => [
    [
        'country' => '',
        'expiry_time' => '',
        'id' => 0
    ]
  ],
  'monetary_account_id_fallback' => 0,
  'order_status' => '',
  'pin_code' => '',
  'pin_code_assignment' => [
    [
        'monetary_account_id' => 0,
        'pin_code' => '',
        'routing_type' => '',
        'type' => ''
    ]
  ],
  'primary_account_numbers' => [
    [
        'description' => '',
        'four_digit' => '',
        'id' => 0,
        'monetary_account_id' => 0,
        'status' => '',
        'uuid' => ''
    ]
  ],
  'status' => ''
]));

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

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

append(json_encode([
  'activation_code' => '',
  'card_limit' => [
    'currency' => '',
    'value' => ''
  ],
  'card_limit_atm' => [
    
  ],
  'country_permission' => [
    [
        'country' => '',
        'expiry_time' => '',
        'id' => 0
    ]
  ],
  'monetary_account_id_fallback' => 0,
  'order_status' => '',
  'pin_code' => '',
  'pin_code_assignment' => [
    [
        'monetary_account_id' => 0,
        'pin_code' => '',
        'routing_type' => '',
        'type' => ''
    ]
  ],
  'primary_account_numbers' => [
    [
        'description' => '',
        'four_digit' => '',
        'id' => 0,
        'monetary_account_id' => 0,
        'status' => '',
        'uuid' => ''
    ]
  ],
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/card/:itemId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/card/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "activation_code": "",
  "card_limit": {
    "currency": "",
    "value": ""
  },
  "card_limit_atm": {},
  "country_permission": [
    {
      "country": "",
      "expiry_time": "",
      "id": 0
    }
  ],
  "monetary_account_id_fallback": 0,
  "order_status": "",
  "pin_code": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "primary_account_numbers": [
    {
      "description": "",
      "four_digit": "",
      "id": 0,
      "monetary_account_id": 0,
      "status": "",
      "uuid": ""
    }
  ],
  "status": ""
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/card/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "activation_code": "",
  "card_limit": {
    "currency": "",
    "value": ""
  },
  "card_limit_atm": {},
  "country_permission": [
    {
      "country": "",
      "expiry_time": "",
      "id": 0
    }
  ],
  "monetary_account_id_fallback": 0,
  "order_status": "",
  "pin_code": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "primary_account_numbers": [
    {
      "description": "",
      "four_digit": "",
      "id": 0,
      "monetary_account_id": 0,
      "status": "",
      "uuid": ""
    }
  ],
  "status": ""
}'

import http.client

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

payload = "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/user/:userID/card/:itemId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/card/:itemId"

payload = {
    "activation_code": "",
    "card_limit": {
        "currency": "",
        "value": ""
    },
    "card_limit_atm": {},
    "country_permission": [
        {
            "country": "",
            "expiry_time": "",
            "id": 0
        }
    ],
    "monetary_account_id_fallback": 0,
    "order_status": "",
    "pin_code": "",
    "pin_code_assignment": [
        {
            "monetary_account_id": 0,
            "pin_code": "",
            "routing_type": "",
            "type": ""
        }
    ],
    "primary_account_numbers": [
        {
            "description": "",
            "four_digit": "",
            "id": 0,
            "monetary_account_id": 0,
            "status": "",
            "uuid": ""
        }
    ],
    "status": ""
}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/card/:itemId"

payload <- "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/card/:itemId")

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

request = Net::HTTP::Put.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/user/:userID/card/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"activation_code\": \"\",\n  \"card_limit\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"card_limit_atm\": {},\n  \"country_permission\": [\n    {\n      \"country\": \"\",\n      \"expiry_time\": \"\",\n      \"id\": 0\n    }\n  ],\n  \"monetary_account_id_fallback\": 0,\n  \"order_status\": \"\",\n  \"pin_code\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"primary_account_numbers\": [\n    {\n      \"description\": \"\",\n      \"four_digit\": \"\",\n      \"id\": 0,\n      \"monetary_account_id\": 0,\n      \"status\": \"\",\n      \"uuid\": \"\"\n    }\n  ],\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "activation_code": "",
        "card_limit": json!({
            "currency": "",
            "value": ""
        }),
        "card_limit_atm": json!({}),
        "country_permission": (
            json!({
                "country": "",
                "expiry_time": "",
                "id": 0
            })
        ),
        "monetary_account_id_fallback": 0,
        "order_status": "",
        "pin_code": "",
        "pin_code_assignment": (
            json!({
                "monetary_account_id": 0,
                "pin_code": "",
                "routing_type": "",
                "type": ""
            })
        ),
        "primary_account_numbers": (
            json!({
                "description": "",
                "four_digit": "",
                "id": 0,
                "monetary_account_id": 0,
                "status": "",
                "uuid": ""
            })
        ),
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".parse().unwrap());
    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 '{
  "activation_code": "",
  "card_limit": {
    "currency": "",
    "value": ""
  },
  "card_limit_atm": {},
  "country_permission": [
    {
      "country": "",
      "expiry_time": "",
      "id": 0
    }
  ],
  "monetary_account_id_fallback": 0,
  "order_status": "",
  "pin_code": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "primary_account_numbers": [
    {
      "description": "",
      "four_digit": "",
      "id": 0,
      "monetary_account_id": 0,
      "status": "",
      "uuid": ""
    }
  ],
  "status": ""
}' |  \
  http PUT {{baseUrl}}/user/:userID/card/:itemId \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method PUT \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "activation_code": "",\n  "card_limit": {\n    "currency": "",\n    "value": ""\n  },\n  "card_limit_atm": {},\n  "country_permission": [\n    {\n      "country": "",\n      "expiry_time": "",\n      "id": 0\n    }\n  ],\n  "monetary_account_id_fallback": 0,\n  "order_status": "",\n  "pin_code": "",\n  "pin_code_assignment": [\n    {\n      "monetary_account_id": 0,\n      "pin_code": "",\n      "routing_type": "",\n      "type": ""\n    }\n  ],\n  "primary_account_numbers": [\n    {\n      "description": "",\n      "four_digit": "",\n      "id": 0,\n      "monetary_account_id": 0,\n      "status": "",\n      "uuid": ""\n    }\n  ],\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/card/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [
  "activation_code": "",
  "card_limit": [
    "currency": "",
    "value": ""
  ],
  "card_limit_atm": [],
  "country_permission": [
    [
      "country": "",
      "expiry_time": "",
      "id": 0
    ]
  ],
  "monetary_account_id_fallback": 0,
  "order_status": "",
  "pin_code": "",
  "pin_code_assignment": [
    [
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    ]
  ],
  "primary_account_numbers": [
    [
      "description": "",
      "four_digit": "",
      "id": 0,
      "monetary_account_id": 0,
      "status": "",
      "uuid": ""
    ]
  ],
  "status": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/card-batch");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/user/:userID/card-batch" {:headers {:user-agent ""
                                                                              :x-bunq-client-authentication ""}
                                                                    :content-type :json
                                                                    :form-params {:cards [{:card_limit {:currency ""
                                                                                                        :value ""}
                                                                                           :card_limit_atm {}
                                                                                           :country_permission [{:country ""
                                                                                                                 :expiry_time ""
                                                                                                                 :id 0}]
                                                                                           :id 0
                                                                                           :monetary_account_id_fallback 0
                                                                                           :status ""}]}})

require "http/client"

url = "{{baseUrl}}/user/:userID/card-batch"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/user/:userID/card-batch"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\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}}/user/:userID/card-batch");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/card-batch"

	payload := strings.NewReader("{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/card-batch HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 341

{
  "cards": [
    {
      "card_limit": {
        "currency": "",
        "value": ""
      },
      "card_limit_atm": {},
      "country_permission": [
        {
          "country": "",
          "expiry_time": "",
          "id": 0
        }
      ],
      "id": 0,
      "monetary_account_id_fallback": 0,
      "status": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/card-batch")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/card-batch"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\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  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/card-batch")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/card-batch")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  cards: [
    {
      card_limit: {
        currency: '',
        value: ''
      },
      card_limit_atm: {},
      country_permission: [
        {
          country: '',
          expiry_time: '',
          id: 0
        }
      ],
      id: 0,
      monetary_account_id_fallback: 0,
      status: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/user/:userID/card-batch');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-batch',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    cards: [
      {
        card_limit: {currency: '', value: ''},
        card_limit_atm: {},
        country_permission: [{country: '', expiry_time: '', id: 0}],
        id: 0,
        monetary_account_id_fallback: 0,
        status: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/user/:userID/card-batch';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"cards":[{"card_limit":{"currency":"","value":""},"card_limit_atm":{},"country_permission":[{"country":"","expiry_time":"","id":0}],"id":0,"monetary_account_id_fallback":0,"status":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/card-batch',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cards": [\n    {\n      "card_limit": {\n        "currency": "",\n        "value": ""\n      },\n      "card_limit_atm": {},\n      "country_permission": [\n        {\n          "country": "",\n          "expiry_time": "",\n          "id": 0\n        }\n      ],\n      "id": 0,\n      "monetary_account_id_fallback": 0,\n      "status": ""\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  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/card-batch")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/card-batch',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({
  cards: [
    {
      card_limit: {currency: '', value: ''},
      card_limit_atm: {},
      country_permission: [{country: '', expiry_time: '', id: 0}],
      id: 0,
      monetary_account_id_fallback: 0,
      status: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-batch',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    cards: [
      {
        card_limit: {currency: '', value: ''},
        card_limit_atm: {},
        country_permission: [{country: '', expiry_time: '', id: 0}],
        id: 0,
        monetary_account_id_fallback: 0,
        status: ''
      }
    ]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/user/:userID/card-batch');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cards: [
    {
      card_limit: {
        currency: '',
        value: ''
      },
      card_limit_atm: {},
      country_permission: [
        {
          country: '',
          expiry_time: '',
          id: 0
        }
      ],
      id: 0,
      monetary_account_id_fallback: 0,
      status: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-batch',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    cards: [
      {
        card_limit: {currency: '', value: ''},
        card_limit_atm: {},
        country_permission: [{country: '', expiry_time: '', id: 0}],
        id: 0,
        monetary_account_id_fallback: 0,
        status: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/user/:userID/card-batch';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"cards":[{"card_limit":{"currency":"","value":""},"card_limit_atm":{},"country_permission":[{"country":"","expiry_time":"","id":0}],"id":0,"monetary_account_id_fallback":0,"status":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cards": @[ @{ @"card_limit": @{ @"currency": @"", @"value": @"" }, @"card_limit_atm": @{  }, @"country_permission": @[ @{ @"country": @"", @"expiry_time": @"", @"id": @0 } ], @"id": @0, @"monetary_account_id_fallback": @0, @"status": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/card-batch"]
                                                       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}}/user/:userID/card-batch" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/user/:userID/card-batch",
  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([
    'cards' => [
        [
                'card_limit' => [
                                'currency' => '',
                                'value' => ''
                ],
                'card_limit_atm' => [
                                
                ],
                'country_permission' => [
                                [
                                                                'country' => '',
                                                                'expiry_time' => '',
                                                                'id' => 0
                                ]
                ],
                'id' => 0,
                'monetary_account_id_fallback' => 0,
                'status' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/user/:userID/card-batch', [
  'body' => '{
  "cards": [
    {
      "card_limit": {
        "currency": "",
        "value": ""
      },
      "card_limit_atm": {},
      "country_permission": [
        {
          "country": "",
          "expiry_time": "",
          "id": 0
        }
      ],
      "id": 0,
      "monetary_account_id_fallback": 0,
      "status": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/card-batch');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cards' => [
    [
        'card_limit' => [
                'currency' => '',
                'value' => ''
        ],
        'card_limit_atm' => [
                
        ],
        'country_permission' => [
                [
                                'country' => '',
                                'expiry_time' => '',
                                'id' => 0
                ]
        ],
        'id' => 0,
        'monetary_account_id_fallback' => 0,
        'status' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'cards' => [
    [
        'card_limit' => [
                'currency' => '',
                'value' => ''
        ],
        'card_limit_atm' => [
                
        ],
        'country_permission' => [
                [
                                'country' => '',
                                'expiry_time' => '',
                                'id' => 0
                ]
        ],
        'id' => 0,
        'monetary_account_id_fallback' => 0,
        'status' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/card-batch');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/card-batch' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cards": [
    {
      "card_limit": {
        "currency": "",
        "value": ""
      },
      "card_limit_atm": {},
      "country_permission": [
        {
          "country": "",
          "expiry_time": "",
          "id": 0
        }
      ],
      "id": 0,
      "monetary_account_id_fallback": 0,
      "status": ""
    }
  ]
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/card-batch' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cards": [
    {
      "card_limit": {
        "currency": "",
        "value": ""
      },
      "card_limit_atm": {},
      "country_permission": [
        {
          "country": "",
          "expiry_time": "",
          "id": 0
        }
      ],
      "id": 0,
      "monetary_account_id_fallback": 0,
      "status": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/card-batch", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/card-batch"

payload = { "cards": [
        {
            "card_limit": {
                "currency": "",
                "value": ""
            },
            "card_limit_atm": {},
            "country_permission": [
                {
                    "country": "",
                    "expiry_time": "",
                    "id": 0
                }
            ],
            "id": 0,
            "monetary_account_id_fallback": 0,
            "status": ""
        }
    ] }
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/card-batch"

payload <- "{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/card-batch")

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

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/user/:userID/card-batch') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"cards\": [\n    {\n      \"card_limit\": {\n        \"currency\": \"\",\n        \"value\": \"\"\n      },\n      \"card_limit_atm\": {},\n      \"country_permission\": [\n        {\n          \"country\": \"\",\n          \"expiry_time\": \"\",\n          \"id\": 0\n        }\n      ],\n      \"id\": 0,\n      \"monetary_account_id_fallback\": 0,\n      \"status\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/card-batch";

    let payload = json!({"cards": (
            json!({
                "card_limit": json!({
                    "currency": "",
                    "value": ""
                }),
                "card_limit_atm": json!({}),
                "country_permission": (
                    json!({
                        "country": "",
                        "expiry_time": "",
                        "id": 0
                    })
                ),
                "id": 0,
                "monetary_account_id_fallback": 0,
                "status": ""
            })
        )});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "cards": [
    {
      "card_limit": {
        "currency": "",
        "value": ""
      },
      "card_limit_atm": {},
      "country_permission": [
        {
          "country": "",
          "expiry_time": "",
          "id": 0
        }
      ],
      "id": 0,
      "monetary_account_id_fallback": 0,
      "status": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/user/:userID/card-batch \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cards": [\n    {\n      "card_limit": {\n        "currency": "",\n        "value": ""\n      },\n      "card_limit_atm": {},\n      "country_permission": [\n        {\n          "country": "",\n          "expiry_time": "",\n          "id": 0\n        }\n      ],\n      "id": 0,\n      "monetary_account_id_fallback": 0,\n      "status": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/card-batch

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = ["cards": [
    [
      "card_limit": [
        "currency": "",
        "value": ""
      ],
      "card_limit_atm": [],
      "country_permission": [
        [
          "country": "",
          "expiry_time": "",
          "id": 0
        ]
      ],
      "id": 0,
      "monetary_account_id_fallback": 0,
      "status": ""
    ]
  ]] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/card-batch-replace");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/user/:userID/card-batch-replace" {:headers {:user-agent ""
                                                                                      :x-bunq-client-authentication ""}
                                                                            :content-type :json
                                                                            :form-params {:cards [{:id 0
                                                                                                   :name_on_card ""
                                                                                                   :pin_code_assignment [{:monetary_account_id 0
                                                                                                                          :pin_code ""
                                                                                                                          :routing_type ""
                                                                                                                          :type ""}]
                                                                                                   :second_line ""}]}})

require "http/client"

url = "{{baseUrl}}/user/:userID/card-batch-replace"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/user/:userID/card-batch-replace"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\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}}/user/:userID/card-batch-replace");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/card-batch-replace"

	payload := strings.NewReader("{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/card-batch-replace HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 270

{
  "cards": [
    {
      "id": 0,
      "name_on_card": "",
      "pin_code_assignment": [
        {
          "monetary_account_id": 0,
          "pin_code": "",
          "routing_type": "",
          "type": ""
        }
      ],
      "second_line": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/card-batch-replace")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/card-batch-replace"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\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  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/card-batch-replace")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/card-batch-replace")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  cards: [
    {
      id: 0,
      name_on_card: '',
      pin_code_assignment: [
        {
          monetary_account_id: 0,
          pin_code: '',
          routing_type: '',
          type: ''
        }
      ],
      second_line: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/user/:userID/card-batch-replace');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-batch-replace',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    cards: [
      {
        id: 0,
        name_on_card: '',
        pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
        second_line: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/user/:userID/card-batch-replace';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"cards":[{"id":0,"name_on_card":"","pin_code_assignment":[{"monetary_account_id":0,"pin_code":"","routing_type":"","type":""}],"second_line":""}]}'
};

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}}/user/:userID/card-batch-replace',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cards": [\n    {\n      "id": 0,\n      "name_on_card": "",\n      "pin_code_assignment": [\n        {\n          "monetary_account_id": 0,\n          "pin_code": "",\n          "routing_type": "",\n          "type": ""\n        }\n      ],\n      "second_line": ""\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  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/card-batch-replace")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/card-batch-replace',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({
  cards: [
    {
      id: 0,
      name_on_card: '',
      pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
      second_line: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-batch-replace',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    cards: [
      {
        id: 0,
        name_on_card: '',
        pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
        second_line: ''
      }
    ]
  },
  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}}/user/:userID/card-batch-replace');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cards: [
    {
      id: 0,
      name_on_card: '',
      pin_code_assignment: [
        {
          monetary_account_id: 0,
          pin_code: '',
          routing_type: '',
          type: ''
        }
      ],
      second_line: ''
    }
  ]
});

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}}/user/:userID/card-batch-replace',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    cards: [
      {
        id: 0,
        name_on_card: '',
        pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
        second_line: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/user/:userID/card-batch-replace';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"cards":[{"id":0,"name_on_card":"","pin_code_assignment":[{"monetary_account_id":0,"pin_code":"","routing_type":"","type":""}],"second_line":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cards": @[ @{ @"id": @0, @"name_on_card": @"", @"pin_code_assignment": @[ @{ @"monetary_account_id": @0, @"pin_code": @"", @"routing_type": @"", @"type": @"" } ], @"second_line": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/card-batch-replace"]
                                                       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}}/user/:userID/card-batch-replace" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/user/:userID/card-batch-replace",
  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([
    'cards' => [
        [
                'id' => 0,
                'name_on_card' => '',
                'pin_code_assignment' => [
                                [
                                                                'monetary_account_id' => 0,
                                                                'pin_code' => '',
                                                                'routing_type' => '',
                                                                'type' => ''
                                ]
                ],
                'second_line' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/user/:userID/card-batch-replace', [
  'body' => '{
  "cards": [
    {
      "id": 0,
      "name_on_card": "",
      "pin_code_assignment": [
        {
          "monetary_account_id": 0,
          "pin_code": "",
          "routing_type": "",
          "type": ""
        }
      ],
      "second_line": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/card-batch-replace');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cards' => [
    [
        'id' => 0,
        'name_on_card' => '',
        'pin_code_assignment' => [
                [
                                'monetary_account_id' => 0,
                                'pin_code' => '',
                                'routing_type' => '',
                                'type' => ''
                ]
        ],
        'second_line' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'cards' => [
    [
        'id' => 0,
        'name_on_card' => '',
        'pin_code_assignment' => [
                [
                                'monetary_account_id' => 0,
                                'pin_code' => '',
                                'routing_type' => '',
                                'type' => ''
                ]
        ],
        'second_line' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/card-batch-replace');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/card-batch-replace' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cards": [
    {
      "id": 0,
      "name_on_card": "",
      "pin_code_assignment": [
        {
          "monetary_account_id": 0,
          "pin_code": "",
          "routing_type": "",
          "type": ""
        }
      ],
      "second_line": ""
    }
  ]
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/card-batch-replace' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cards": [
    {
      "id": 0,
      "name_on_card": "",
      "pin_code_assignment": [
        {
          "monetary_account_id": 0,
          "pin_code": "",
          "routing_type": "",
          "type": ""
        }
      ],
      "second_line": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/card-batch-replace", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/card-batch-replace"

payload = { "cards": [
        {
            "id": 0,
            "name_on_card": "",
            "pin_code_assignment": [
                {
                    "monetary_account_id": 0,
                    "pin_code": "",
                    "routing_type": "",
                    "type": ""
                }
            ],
            "second_line": ""
        }
    ] }
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/card-batch-replace"

payload <- "{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/card-batch-replace")

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

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/user/:userID/card-batch-replace') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"cards\": [\n    {\n      \"id\": 0,\n      \"name_on_card\": \"\",\n      \"pin_code_assignment\": [\n        {\n          \"monetary_account_id\": 0,\n          \"pin_code\": \"\",\n          \"routing_type\": \"\",\n          \"type\": \"\"\n        }\n      ],\n      \"second_line\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/card-batch-replace";

    let payload = json!({"cards": (
            json!({
                "id": 0,
                "name_on_card": "",
                "pin_code_assignment": (
                    json!({
                        "monetary_account_id": 0,
                        "pin_code": "",
                        "routing_type": "",
                        "type": ""
                    })
                ),
                "second_line": ""
            })
        )});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "cards": [
    {
      "id": 0,
      "name_on_card": "",
      "pin_code_assignment": [
        {
          "monetary_account_id": 0,
          "pin_code": "",
          "routing_type": "",
          "type": ""
        }
      ],
      "second_line": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/user/:userID/card-batch-replace \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cards": [\n    {\n      "id": 0,\n      "name_on_card": "",\n      "pin_code_assignment": [\n        {\n          "monetary_account_id": 0,\n          "pin_code": "",\n          "routing_type": "",\n          "type": ""\n        }\n      ],\n      "second_line": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/card-batch-replace

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = ["cards": [
    [
      "id": 0,
      "name_on_card": "",
      "pin_code_assignment": [
        [
          "monetary_account_id": 0,
          "pin_code": "",
          "routing_type": "",
          "type": ""
        ]
      ],
      "second_line": ""
    ]
  ]] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/card-credit");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/user/:userID/card-credit" {:headers {:user-agent ""
                                                                               :x-bunq-client-authentication ""}
                                                                     :content-type :json
                                                                     :form-params {:alias {:name ""
                                                                                           :service ""
                                                                                           :type ""
                                                                                           :value ""}
                                                                                   :monetary_account_id_fallback 0
                                                                                   :name_on_card ""
                                                                                   :order_status ""
                                                                                   :pin_code_assignment [{:monetary_account_id 0
                                                                                                          :pin_code ""
                                                                                                          :routing_type ""
                                                                                                          :type ""}]
                                                                                   :preferred_name_on_card ""
                                                                                   :product_type ""
                                                                                   :second_line ""
                                                                                   :type ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/card-credit"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/user/:userID/card-credit"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/card-credit");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/card-credit"

	payload := strings.NewReader("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/card-credit HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 398

{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/card-credit")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/card-credit"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/card-credit")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/card-credit")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  alias: {
    name: '',
    service: '',
    type: '',
    value: ''
  },
  monetary_account_id_fallback: 0,
  name_on_card: '',
  order_status: '',
  pin_code_assignment: [
    {
      monetary_account_id: 0,
      pin_code: '',
      routing_type: '',
      type: ''
    }
  ],
  preferred_name_on_card: '',
  product_type: '',
  second_line: '',
  type: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/user/:userID/card-credit');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-credit',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    alias: {name: '', service: '', type: '', value: ''},
    monetary_account_id_fallback: 0,
    name_on_card: '',
    order_status: '',
    pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
    preferred_name_on_card: '',
    product_type: '',
    second_line: '',
    type: ''
  }
};

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

const url = '{{baseUrl}}/user/:userID/card-credit';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"alias":{"name":"","service":"","type":"","value":""},"monetary_account_id_fallback":0,"name_on_card":"","order_status":"","pin_code_assignment":[{"monetary_account_id":0,"pin_code":"","routing_type":"","type":""}],"preferred_name_on_card":"","product_type":"","second_line":"","type":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/card-credit',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alias": {\n    "name": "",\n    "service": "",\n    "type": "",\n    "value": ""\n  },\n  "monetary_account_id_fallback": 0,\n  "name_on_card": "",\n  "order_status": "",\n  "pin_code_assignment": [\n    {\n      "monetary_account_id": 0,\n      "pin_code": "",\n      "routing_type": "",\n      "type": ""\n    }\n  ],\n  "preferred_name_on_card": "",\n  "product_type": "",\n  "second_line": "",\n  "type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/card-credit")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/card-credit',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({
  alias: {name: '', service: '', type: '', value: ''},
  monetary_account_id_fallback: 0,
  name_on_card: '',
  order_status: '',
  pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
  preferred_name_on_card: '',
  product_type: '',
  second_line: '',
  type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-credit',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    alias: {name: '', service: '', type: '', value: ''},
    monetary_account_id_fallback: 0,
    name_on_card: '',
    order_status: '',
    pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
    preferred_name_on_card: '',
    product_type: '',
    second_line: '',
    type: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/user/:userID/card-credit');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alias: {
    name: '',
    service: '',
    type: '',
    value: ''
  },
  monetary_account_id_fallback: 0,
  name_on_card: '',
  order_status: '',
  pin_code_assignment: [
    {
      monetary_account_id: 0,
      pin_code: '',
      routing_type: '',
      type: ''
    }
  ],
  preferred_name_on_card: '',
  product_type: '',
  second_line: '',
  type: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-credit',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    alias: {name: '', service: '', type: '', value: ''},
    monetary_account_id_fallback: 0,
    name_on_card: '',
    order_status: '',
    pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
    preferred_name_on_card: '',
    product_type: '',
    second_line: '',
    type: ''
  }
};

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

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

const url = '{{baseUrl}}/user/:userID/card-credit';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"alias":{"name":"","service":"","type":"","value":""},"monetary_account_id_fallback":0,"name_on_card":"","order_status":"","pin_code_assignment":[{"monetary_account_id":0,"pin_code":"","routing_type":"","type":""}],"preferred_name_on_card":"","product_type":"","second_line":"","type":""}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alias": @{ @"name": @"", @"service": @"", @"type": @"", @"value": @"" },
                              @"monetary_account_id_fallback": @0,
                              @"name_on_card": @"",
                              @"order_status": @"",
                              @"pin_code_assignment": @[ @{ @"monetary_account_id": @0, @"pin_code": @"", @"routing_type": @"", @"type": @"" } ],
                              @"preferred_name_on_card": @"",
                              @"product_type": @"",
                              @"second_line": @"",
                              @"type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/card-credit"]
                                                       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}}/user/:userID/card-credit" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}" in

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

 "{{baseUrl}}/user/:userID/card-credit",
  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([
    'alias' => [
        'name' => '',
        'service' => '',
        'type' => '',
        'value' => ''
    ],
    'monetary_account_id_fallback' => 0,
    'name_on_card' => '',
    'order_status' => '',
    'pin_code_assignment' => [
        [
                'monetary_account_id' => 0,
                'pin_code' => '',
                'routing_type' => '',
                'type' => ''
        ]
    ],
    'preferred_name_on_card' => '',
    'product_type' => '',
    'second_line' => '',
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/user/:userID/card-credit', [
  'body' => '{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/card-credit');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alias' => [
    'name' => '',
    'service' => '',
    'type' => '',
    'value' => ''
  ],
  'monetary_account_id_fallback' => 0,
  'name_on_card' => '',
  'order_status' => '',
  'pin_code_assignment' => [
    [
        'monetary_account_id' => 0,
        'pin_code' => '',
        'routing_type' => '',
        'type' => ''
    ]
  ],
  'preferred_name_on_card' => '',
  'product_type' => '',
  'second_line' => '',
  'type' => ''
]));

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

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

append(json_encode([
  'alias' => [
    'name' => '',
    'service' => '',
    'type' => '',
    'value' => ''
  ],
  'monetary_account_id_fallback' => 0,
  'name_on_card' => '',
  'order_status' => '',
  'pin_code_assignment' => [
    [
        'monetary_account_id' => 0,
        'pin_code' => '',
        'routing_type' => '',
        'type' => ''
    ]
  ],
  'preferred_name_on_card' => '',
  'product_type' => '',
  'second_line' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/card-credit');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/card-credit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/card-credit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}'

import http.client

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

payload = "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/card-credit", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/card-credit"

payload = {
    "alias": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
    },
    "monetary_account_id_fallback": 0,
    "name_on_card": "",
    "order_status": "",
    "pin_code_assignment": [
        {
            "monetary_account_id": 0,
            "pin_code": "",
            "routing_type": "",
            "type": ""
        }
    ],
    "preferred_name_on_card": "",
    "product_type": "",
    "second_line": "",
    "type": ""
}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/card-credit"

payload <- "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/card-credit")

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

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/user/:userID/card-credit') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/card-credit";

    let payload = json!({
        "alias": json!({
            "name": "",
            "service": "",
            "type": "",
            "value": ""
        }),
        "monetary_account_id_fallback": 0,
        "name_on_card": "",
        "order_status": "",
        "pin_code_assignment": (
            json!({
                "monetary_account_id": 0,
                "pin_code": "",
                "routing_type": "",
                "type": ""
            })
        ),
        "preferred_name_on_card": "",
        "product_type": "",
        "second_line": "",
        "type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}' |  \
  http POST {{baseUrl}}/user/:userID/card-credit \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "alias": {\n    "name": "",\n    "service": "",\n    "type": "",\n    "value": ""\n  },\n  "monetary_account_id_fallback": 0,\n  "name_on_card": "",\n  "order_status": "",\n  "pin_code_assignment": [\n    {\n      "monetary_account_id": 0,\n      "pin_code": "",\n      "routing_type": "",\n      "type": ""\n    }\n  ],\n  "preferred_name_on_card": "",\n  "product_type": "",\n  "second_line": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/card-credit

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [
  "alias": [
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  ],
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    [
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    ]
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/card-debit");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/user/:userID/card-debit" {:headers {:user-agent ""
                                                                              :x-bunq-client-authentication ""}
                                                                    :content-type :json
                                                                    :form-params {:alias {:name ""
                                                                                          :service ""
                                                                                          :type ""
                                                                                          :value ""}
                                                                                  :monetary_account_id_fallback 0
                                                                                  :name_on_card ""
                                                                                  :order_status ""
                                                                                  :pin_code_assignment [{:monetary_account_id 0
                                                                                                         :pin_code ""
                                                                                                         :routing_type ""
                                                                                                         :type ""}]
                                                                                  :preferred_name_on_card ""
                                                                                  :product_type ""
                                                                                  :second_line ""
                                                                                  :type ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/card-debit"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/user/:userID/card-debit"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/card-debit");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/card-debit"

	payload := strings.NewReader("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/card-debit HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 398

{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/card-debit")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/card-debit"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/card-debit")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/card-debit")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  alias: {
    name: '',
    service: '',
    type: '',
    value: ''
  },
  monetary_account_id_fallback: 0,
  name_on_card: '',
  order_status: '',
  pin_code_assignment: [
    {
      monetary_account_id: 0,
      pin_code: '',
      routing_type: '',
      type: ''
    }
  ],
  preferred_name_on_card: '',
  product_type: '',
  second_line: '',
  type: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/user/:userID/card-debit');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-debit',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    alias: {name: '', service: '', type: '', value: ''},
    monetary_account_id_fallback: 0,
    name_on_card: '',
    order_status: '',
    pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
    preferred_name_on_card: '',
    product_type: '',
    second_line: '',
    type: ''
  }
};

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

const url = '{{baseUrl}}/user/:userID/card-debit';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"alias":{"name":"","service":"","type":"","value":""},"monetary_account_id_fallback":0,"name_on_card":"","order_status":"","pin_code_assignment":[{"monetary_account_id":0,"pin_code":"","routing_type":"","type":""}],"preferred_name_on_card":"","product_type":"","second_line":"","type":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/card-debit',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alias": {\n    "name": "",\n    "service": "",\n    "type": "",\n    "value": ""\n  },\n  "monetary_account_id_fallback": 0,\n  "name_on_card": "",\n  "order_status": "",\n  "pin_code_assignment": [\n    {\n      "monetary_account_id": 0,\n      "pin_code": "",\n      "routing_type": "",\n      "type": ""\n    }\n  ],\n  "preferred_name_on_card": "",\n  "product_type": "",\n  "second_line": "",\n  "type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/card-debit")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/card-debit',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({
  alias: {name: '', service: '', type: '', value: ''},
  monetary_account_id_fallback: 0,
  name_on_card: '',
  order_status: '',
  pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
  preferred_name_on_card: '',
  product_type: '',
  second_line: '',
  type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-debit',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    alias: {name: '', service: '', type: '', value: ''},
    monetary_account_id_fallback: 0,
    name_on_card: '',
    order_status: '',
    pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
    preferred_name_on_card: '',
    product_type: '',
    second_line: '',
    type: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/user/:userID/card-debit');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alias: {
    name: '',
    service: '',
    type: '',
    value: ''
  },
  monetary_account_id_fallback: 0,
  name_on_card: '',
  order_status: '',
  pin_code_assignment: [
    {
      monetary_account_id: 0,
      pin_code: '',
      routing_type: '',
      type: ''
    }
  ],
  preferred_name_on_card: '',
  product_type: '',
  second_line: '',
  type: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/card-debit',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    alias: {name: '', service: '', type: '', value: ''},
    monetary_account_id_fallback: 0,
    name_on_card: '',
    order_status: '',
    pin_code_assignment: [{monetary_account_id: 0, pin_code: '', routing_type: '', type: ''}],
    preferred_name_on_card: '',
    product_type: '',
    second_line: '',
    type: ''
  }
};

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

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

const url = '{{baseUrl}}/user/:userID/card-debit';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"alias":{"name":"","service":"","type":"","value":""},"monetary_account_id_fallback":0,"name_on_card":"","order_status":"","pin_code_assignment":[{"monetary_account_id":0,"pin_code":"","routing_type":"","type":""}],"preferred_name_on_card":"","product_type":"","second_line":"","type":""}'
};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alias": @{ @"name": @"", @"service": @"", @"type": @"", @"value": @"" },
                              @"monetary_account_id_fallback": @0,
                              @"name_on_card": @"",
                              @"order_status": @"",
                              @"pin_code_assignment": @[ @{ @"monetary_account_id": @0, @"pin_code": @"", @"routing_type": @"", @"type": @"" } ],
                              @"preferred_name_on_card": @"",
                              @"product_type": @"",
                              @"second_line": @"",
                              @"type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/card-debit"]
                                                       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}}/user/:userID/card-debit" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}" in

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

 "{{baseUrl}}/user/:userID/card-debit",
  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([
    'alias' => [
        'name' => '',
        'service' => '',
        'type' => '',
        'value' => ''
    ],
    'monetary_account_id_fallback' => 0,
    'name_on_card' => '',
    'order_status' => '',
    'pin_code_assignment' => [
        [
                'monetary_account_id' => 0,
                'pin_code' => '',
                'routing_type' => '',
                'type' => ''
        ]
    ],
    'preferred_name_on_card' => '',
    'product_type' => '',
    'second_line' => '',
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/user/:userID/card-debit', [
  'body' => '{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/card-debit');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alias' => [
    'name' => '',
    'service' => '',
    'type' => '',
    'value' => ''
  ],
  'monetary_account_id_fallback' => 0,
  'name_on_card' => '',
  'order_status' => '',
  'pin_code_assignment' => [
    [
        'monetary_account_id' => 0,
        'pin_code' => '',
        'routing_type' => '',
        'type' => ''
    ]
  ],
  'preferred_name_on_card' => '',
  'product_type' => '',
  'second_line' => '',
  'type' => ''
]));

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

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

append(json_encode([
  'alias' => [
    'name' => '',
    'service' => '',
    'type' => '',
    'value' => ''
  ],
  'monetary_account_id_fallback' => 0,
  'name_on_card' => '',
  'order_status' => '',
  'pin_code_assignment' => [
    [
        'monetary_account_id' => 0,
        'pin_code' => '',
        'routing_type' => '',
        'type' => ''
    ]
  ],
  'preferred_name_on_card' => '',
  'product_type' => '',
  'second_line' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/card-debit');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/card-debit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/card-debit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}'

import http.client

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

payload = "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/card-debit", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user/:userID/card-debit"

payload = {
    "alias": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
    },
    "monetary_account_id_fallback": 0,
    "name_on_card": "",
    "order_status": "",
    "pin_code_assignment": [
        {
            "monetary_account_id": 0,
            "pin_code": "",
            "routing_type": "",
            "type": ""
        }
    ],
    "preferred_name_on_card": "",
    "product_type": "",
    "second_line": "",
    "type": ""
}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/card-debit"

payload <- "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/card-debit")

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

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/user/:userID/card-debit') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"alias\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  },\n  \"monetary_account_id_fallback\": 0,\n  \"name_on_card\": \"\",\n  \"order_status\": \"\",\n  \"pin_code_assignment\": [\n    {\n      \"monetary_account_id\": 0,\n      \"pin_code\": \"\",\n      \"routing_type\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"preferred_name_on_card\": \"\",\n  \"product_type\": \"\",\n  \"second_line\": \"\",\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/card-debit";

    let payload = json!({
        "alias": json!({
            "name": "",
            "service": "",
            "type": "",
            "value": ""
        }),
        "monetary_account_id_fallback": 0,
        "name_on_card": "",
        "order_status": "",
        "pin_code_assignment": (
            json!({
                "monetary_account_id": 0,
                "pin_code": "",
                "routing_type": "",
                "type": ""
            })
        ),
        "preferred_name_on_card": "",
        "product_type": "",
        "second_line": "",
        "type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "alias": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  },
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    {
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    }
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
}' |  \
  http POST {{baseUrl}}/user/:userID/card-debit \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "alias": {\n    "name": "",\n    "service": "",\n    "type": "",\n    "value": ""\n  },\n  "monetary_account_id_fallback": 0,\n  "name_on_card": "",\n  "order_status": "",\n  "pin_code_assignment": [\n    {\n      "monetary_account_id": 0,\n      "pin_code": "",\n      "routing_type": "",\n      "type": ""\n    }\n  ],\n  "preferred_name_on_card": "",\n  "product_type": "",\n  "second_line": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/card-debit

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [
  "alias": [
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  ],
  "monetary_account_id_fallback": 0,
  "name_on_card": "",
  "order_status": "",
  "pin_code_assignment": [
    [
      "monetary_account_id": 0,
      "pin_code": "",
      "routing_type": "",
      "type": ""
    ]
  ],
  "preferred_name_on_card": "",
  "product_type": "",
  "second_line": "",
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/card-name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/user/:userID/card-name" {:headers {:user-agent ""
                                                                            :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/card-name"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/card-name"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/card-name");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user/:userID/card-name"

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

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

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

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

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

}

GET /baseUrl/user/:userID/card-name HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/card-name")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/card-name"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/card-name")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/card-name")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/card-name');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/card-name',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

const url = '{{baseUrl}}/user/:userID/card-name';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/card-name',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/card-name")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/card-name',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/card-name',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/card-name');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/card-name',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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

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

const url = '{{baseUrl}}/user/:userID/card-name';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/card-name"]
                                                       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}}/user/:userID/card-name" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

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

 "{{baseUrl}}/user/:userID/card-name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/card-name', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/card-name');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/card-name');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/card-name' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/card-name' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/card-name", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/card-name"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/card-name"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/card-name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/card-name') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/card-name";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/card-name \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/card-name

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/card-name")! 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}}/user/:userID/certificate-pinned");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/user/:userID/certificate-pinned" {:headers {:user-agent ""
                                                                                      :x-bunq-client-authentication ""}
                                                                            :content-type :json
                                                                            :form-params {:certificate_chain [{:certificate ""}]}})

require "http/client"

url = "{{baseUrl}}/user/:userID/certificate-pinned"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/user/:userID/certificate-pinned"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\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}}/user/:userID/certificate-pinned");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/certificate-pinned"

	payload := strings.NewReader("{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/certificate-pinned HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 68

{
  "certificate_chain": [
    {
      "certificate": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/certificate-pinned")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/certificate-pinned"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\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  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/certificate-pinned")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/certificate-pinned")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  certificate_chain: [
    {
      certificate: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/user/:userID/certificate-pinned');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/certificate-pinned',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {certificate_chain: [{certificate: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/certificate-pinned';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"certificate_chain":[{"certificate":""}]}'
};

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}}/user/:userID/certificate-pinned',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "certificate_chain": [\n    {\n      "certificate": ""\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  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/certificate-pinned")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/certificate-pinned',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({certificate_chain: [{certificate: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/certificate-pinned',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {certificate_chain: [{certificate: ''}]},
  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}}/user/:userID/certificate-pinned');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  certificate_chain: [
    {
      certificate: ''
    }
  ]
});

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}}/user/:userID/certificate-pinned',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {certificate_chain: [{certificate: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/certificate-pinned';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"certificate_chain":[{"certificate":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"certificate_chain": @[ @{ @"certificate": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/certificate-pinned"]
                                                       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}}/user/:userID/certificate-pinned" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/certificate-pinned",
  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([
    'certificate_chain' => [
        [
                'certificate' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/user/:userID/certificate-pinned', [
  'body' => '{
  "certificate_chain": [
    {
      "certificate": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/certificate-pinned');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'certificate_chain' => [
    [
        'certificate' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'certificate_chain' => [
    [
        'certificate' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/certificate-pinned');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/certificate-pinned' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "certificate_chain": [
    {
      "certificate": ""
    }
  ]
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/certificate-pinned' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "certificate_chain": [
    {
      "certificate": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/certificate-pinned", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/certificate-pinned"

payload = { "certificate_chain": [{ "certificate": "" }] }
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/certificate-pinned"

payload <- "{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/certificate-pinned")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/user/:userID/certificate-pinned') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"certificate_chain\": [\n    {\n      \"certificate\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/certificate-pinned";

    let payload = json!({"certificate_chain": (json!({"certificate": ""}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "certificate_chain": [
    {
      "certificate": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/user/:userID/certificate-pinned \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "certificate_chain": [\n    {\n      "certificate": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/certificate-pinned

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = ["certificate_chain": [["certificate": ""]]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/certificate-pinned")! 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}}/user/:userID/certificate-pinned/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/user/:userID/certificate-pinned/:itemId" {:headers {:user-agent ""
                                                                                                :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/certificate-pinned/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/certificate-pinned/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/certificate-pinned/:itemId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/certificate-pinned/:itemId"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/user/:userID/certificate-pinned/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/user/:userID/certificate-pinned/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/certificate-pinned/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/certificate-pinned/:itemId")
  .delete(null)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/user/:userID/certificate-pinned/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/certificate-pinned/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/user/:userID/certificate-pinned/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/certificate-pinned/:itemId';
const options = {
  method: 'DELETE',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

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}}/user/:userID/certificate-pinned/:itemId',
  method: 'DELETE',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/certificate-pinned/:itemId")
  .delete(null)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/certificate-pinned/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/certificate-pinned/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/user/:userID/certificate-pinned/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/certificate-pinned/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/certificate-pinned/:itemId';
const options = {
  method: 'DELETE',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/certificate-pinned/:itemId"]
                                                       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}}/user/:userID/certificate-pinned/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/certificate-pinned/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/user/:userID/certificate-pinned/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/certificate-pinned/:itemId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/certificate-pinned/:itemId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/certificate-pinned/:itemId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/certificate-pinned/:itemId' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("DELETE", "/baseUrl/user/:userID/certificate-pinned/:itemId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/certificate-pinned/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/certificate-pinned/:itemId"

response <- VERB("DELETE", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/certificate-pinned/:itemId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/user/:userID/certificate-pinned/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/certificate-pinned/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/certificate-pinned/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method DELETE \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/certificate-pinned/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/certificate-pinned/:itemId")! 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}}/user/:userID/certificate-pinned");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/certificate-pinned" {:headers {:user-agent ""
                                                                                     :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/certificate-pinned"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/certificate-pinned"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/certificate-pinned");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/certificate-pinned"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/certificate-pinned HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/certificate-pinned")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/certificate-pinned"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/certificate-pinned")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/certificate-pinned")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/certificate-pinned');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/certificate-pinned',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/certificate-pinned';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/certificate-pinned',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/certificate-pinned")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/certificate-pinned',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/certificate-pinned',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/certificate-pinned');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/certificate-pinned',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/certificate-pinned';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/certificate-pinned"]
                                                       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}}/user/:userID/certificate-pinned" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/certificate-pinned",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/certificate-pinned', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/certificate-pinned');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/certificate-pinned');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/certificate-pinned' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/certificate-pinned' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/certificate-pinned", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/certificate-pinned"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/certificate-pinned"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/certificate-pinned")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/certificate-pinned') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/certificate-pinned";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/certificate-pinned \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/certificate-pinned

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/certificate-pinned")! 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}}/user/:userID/certificate-pinned/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/certificate-pinned/:itemId" {:headers {:user-agent ""
                                                                                             :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/certificate-pinned/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/certificate-pinned/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/certificate-pinned/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/certificate-pinned/:itemId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/certificate-pinned/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/certificate-pinned/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/certificate-pinned/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/certificate-pinned/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/certificate-pinned/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/certificate-pinned/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/certificate-pinned/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/certificate-pinned/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/certificate-pinned/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/certificate-pinned/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/certificate-pinned/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/certificate-pinned/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/certificate-pinned/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/certificate-pinned/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/certificate-pinned/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/certificate-pinned/:itemId"]
                                                       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}}/user/:userID/certificate-pinned/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/certificate-pinned/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/certificate-pinned/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/certificate-pinned/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/certificate-pinned/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/certificate-pinned/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/certificate-pinned/:itemId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/certificate-pinned/:itemId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/certificate-pinned/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/certificate-pinned/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/certificate-pinned/:itemId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/certificate-pinned/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/certificate-pinned/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/certificate-pinned/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/certificate-pinned/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/certificate-pinned/:itemId")! 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}}/user/:userID/challenge-request/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/challenge-request/:itemId" {:headers {:user-agent ""
                                                                                            :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/challenge-request/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/challenge-request/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/challenge-request/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/challenge-request/:itemId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/challenge-request/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/challenge-request/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/challenge-request/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/challenge-request/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/challenge-request/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/challenge-request/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/challenge-request/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/challenge-request/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/challenge-request/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/challenge-request/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/challenge-request/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/challenge-request/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/challenge-request/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/challenge-request/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/challenge-request/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/challenge-request/:itemId"]
                                                       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}}/user/:userID/challenge-request/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/challenge-request/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/challenge-request/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/challenge-request/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/challenge-request/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/challenge-request/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/challenge-request/:itemId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/challenge-request/:itemId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/challenge-request/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/challenge-request/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/challenge-request/:itemId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/challenge-request/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/challenge-request/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/challenge-request/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/challenge-request/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/challenge-request/:itemId")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/challenge-request/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/user/:userID/challenge-request/:itemId" {:headers {:user-agent ""
                                                                                            :x-bunq-client-authentication ""}
                                                                                  :content-type :json
                                                                                  :form-params {:status ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/challenge-request/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"status\": \"\"\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}}/user/:userID/challenge-request/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/challenge-request/:itemId");
var request = new RestRequest("", Method.Put);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/challenge-request/:itemId"

	payload := strings.NewReader("{\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/challenge-request/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/user/:userID/challenge-request/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/challenge-request/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/challenge-request/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/user/:userID/challenge-request/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/user/:userID/challenge-request/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/challenge-request/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/challenge-request/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/challenge-request/:itemId',
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/challenge-request/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/challenge-request/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/challenge-request/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {status: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/user/:userID/challenge-request/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/challenge-request/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/challenge-request/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/challenge-request/:itemId"]
                                                       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}}/user/:userID/challenge-request/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/challenge-request/:itemId",
  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([
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/user/:userID/challenge-request/:itemId', [
  'body' => '{
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/challenge-request/:itemId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/challenge-request/:itemId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/challenge-request/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "status": ""
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/challenge-request/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"status\": \"\"\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/user/:userID/challenge-request/:itemId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/challenge-request/:itemId"

payload = { "status": "" }
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/challenge-request/:itemId"

payload <- "{\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/challenge-request/:itemId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"status\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/user/:userID/challenge-request/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/challenge-request/:itemId";

    let payload = json!({"status": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".parse().unwrap());
    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 '{
  "status": ""
}' |  \
  http PUT {{baseUrl}}/user/:userID/challenge-request/:itemId \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method PUT \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/challenge-request/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = ["status": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/challenge-request/:itemId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/company");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/user/:userID/company" {:headers {:user-agent ""
                                                                           :x-bunq-client-authentication ""}
                                                                 :content-type :json
                                                                 :form-params {:address_main {:city ""
                                                                                              :country ""
                                                                                              :extra ""
                                                                                              :house_number ""
                                                                                              :is_user_address_updated false
                                                                                              :mailbox_name ""
                                                                                              :po_box ""
                                                                                              :postal_code ""
                                                                                              :province ""
                                                                                              :street ""}
                                                                               :address_postal {}
                                                                               :avatar_uuid ""
                                                                               :chamber_of_commerce_number ""
                                                                               :country ""
                                                                               :legal_form ""
                                                                               :name ""
                                                                               :signup_track_type ""
                                                                               :subscription_type ""
                                                                               :ubo [{:date_of_birth ""
                                                                                      :name ""
                                                                                      :nationality ""}]
                                                                               :vat_number {:country ""
                                                                                            :value ""}}})

require "http/client"

url = "{{baseUrl}}/user/:userID/company"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/user/:userID/company"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\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}}/user/:userID/company");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/company"

	payload := strings.NewReader("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/company HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 584

{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/company")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/company"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/company")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/company")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  address_main: {
    city: '',
    country: '',
    extra: '',
    house_number: '',
    is_user_address_updated: false,
    mailbox_name: '',
    po_box: '',
    postal_code: '',
    province: '',
    street: ''
  },
  address_postal: {},
  avatar_uuid: '',
  chamber_of_commerce_number: '',
  country: '',
  legal_form: '',
  name: '',
  signup_track_type: '',
  subscription_type: '',
  ubo: [
    {
      date_of_birth: '',
      name: '',
      nationality: ''
    }
  ],
  vat_number: {
    country: '',
    value: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/user/:userID/company');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/company',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    address_main: {
      city: '',
      country: '',
      extra: '',
      house_number: '',
      is_user_address_updated: false,
      mailbox_name: '',
      po_box: '',
      postal_code: '',
      province: '',
      street: ''
    },
    address_postal: {},
    avatar_uuid: '',
    chamber_of_commerce_number: '',
    country: '',
    legal_form: '',
    name: '',
    signup_track_type: '',
    subscription_type: '',
    ubo: [{date_of_birth: '', name: '', nationality: ''}],
    vat_number: {country: '', value: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/company';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"address_main":{"city":"","country":"","extra":"","house_number":"","is_user_address_updated":false,"mailbox_name":"","po_box":"","postal_code":"","province":"","street":""},"address_postal":{},"avatar_uuid":"","chamber_of_commerce_number":"","country":"","legal_form":"","name":"","signup_track_type":"","subscription_type":"","ubo":[{"date_of_birth":"","name":"","nationality":""}],"vat_number":{"country":"","value":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/company',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address_main": {\n    "city": "",\n    "country": "",\n    "extra": "",\n    "house_number": "",\n    "is_user_address_updated": false,\n    "mailbox_name": "",\n    "po_box": "",\n    "postal_code": "",\n    "province": "",\n    "street": ""\n  },\n  "address_postal": {},\n  "avatar_uuid": "",\n  "chamber_of_commerce_number": "",\n  "country": "",\n  "legal_form": "",\n  "name": "",\n  "signup_track_type": "",\n  "subscription_type": "",\n  "ubo": [\n    {\n      "date_of_birth": "",\n      "name": "",\n      "nationality": ""\n    }\n  ],\n  "vat_number": {\n    "country": "",\n    "value": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/company")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/company',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  address_main: {
    city: '',
    country: '',
    extra: '',
    house_number: '',
    is_user_address_updated: false,
    mailbox_name: '',
    po_box: '',
    postal_code: '',
    province: '',
    street: ''
  },
  address_postal: {},
  avatar_uuid: '',
  chamber_of_commerce_number: '',
  country: '',
  legal_form: '',
  name: '',
  signup_track_type: '',
  subscription_type: '',
  ubo: [{date_of_birth: '', name: '', nationality: ''}],
  vat_number: {country: '', value: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/company',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    address_main: {
      city: '',
      country: '',
      extra: '',
      house_number: '',
      is_user_address_updated: false,
      mailbox_name: '',
      po_box: '',
      postal_code: '',
      province: '',
      street: ''
    },
    address_postal: {},
    avatar_uuid: '',
    chamber_of_commerce_number: '',
    country: '',
    legal_form: '',
    name: '',
    signup_track_type: '',
    subscription_type: '',
    ubo: [{date_of_birth: '', name: '', nationality: ''}],
    vat_number: {country: '', value: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/user/:userID/company');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  address_main: {
    city: '',
    country: '',
    extra: '',
    house_number: '',
    is_user_address_updated: false,
    mailbox_name: '',
    po_box: '',
    postal_code: '',
    province: '',
    street: ''
  },
  address_postal: {},
  avatar_uuid: '',
  chamber_of_commerce_number: '',
  country: '',
  legal_form: '',
  name: '',
  signup_track_type: '',
  subscription_type: '',
  ubo: [
    {
      date_of_birth: '',
      name: '',
      nationality: ''
    }
  ],
  vat_number: {
    country: '',
    value: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/company',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    address_main: {
      city: '',
      country: '',
      extra: '',
      house_number: '',
      is_user_address_updated: false,
      mailbox_name: '',
      po_box: '',
      postal_code: '',
      province: '',
      street: ''
    },
    address_postal: {},
    avatar_uuid: '',
    chamber_of_commerce_number: '',
    country: '',
    legal_form: '',
    name: '',
    signup_track_type: '',
    subscription_type: '',
    ubo: [{date_of_birth: '', name: '', nationality: ''}],
    vat_number: {country: '', value: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/company';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"address_main":{"city":"","country":"","extra":"","house_number":"","is_user_address_updated":false,"mailbox_name":"","po_box":"","postal_code":"","province":"","street":""},"address_postal":{},"avatar_uuid":"","chamber_of_commerce_number":"","country":"","legal_form":"","name":"","signup_track_type":"","subscription_type":"","ubo":[{"date_of_birth":"","name":"","nationality":""}],"vat_number":{"country":"","value":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"address_main": @{ @"city": @"", @"country": @"", @"extra": @"", @"house_number": @"", @"is_user_address_updated": @NO, @"mailbox_name": @"", @"po_box": @"", @"postal_code": @"", @"province": @"", @"street": @"" },
                              @"address_postal": @{  },
                              @"avatar_uuid": @"",
                              @"chamber_of_commerce_number": @"",
                              @"country": @"",
                              @"legal_form": @"",
                              @"name": @"",
                              @"signup_track_type": @"",
                              @"subscription_type": @"",
                              @"ubo": @[ @{ @"date_of_birth": @"", @"name": @"", @"nationality": @"" } ],
                              @"vat_number": @{ @"country": @"", @"value": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/company"]
                                                       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}}/user/:userID/company" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/company",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'address_main' => [
        'city' => '',
        'country' => '',
        'extra' => '',
        'house_number' => '',
        'is_user_address_updated' => null,
        'mailbox_name' => '',
        'po_box' => '',
        'postal_code' => '',
        'province' => '',
        'street' => ''
    ],
    'address_postal' => [
        
    ],
    'avatar_uuid' => '',
    'chamber_of_commerce_number' => '',
    'country' => '',
    'legal_form' => '',
    'name' => '',
    'signup_track_type' => '',
    'subscription_type' => '',
    'ubo' => [
        [
                'date_of_birth' => '',
                'name' => '',
                'nationality' => ''
        ]
    ],
    'vat_number' => [
        'country' => '',
        'value' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/user/:userID/company', [
  'body' => '{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/company');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address_main' => [
    'city' => '',
    'country' => '',
    'extra' => '',
    'house_number' => '',
    'is_user_address_updated' => null,
    'mailbox_name' => '',
    'po_box' => '',
    'postal_code' => '',
    'province' => '',
    'street' => ''
  ],
  'address_postal' => [
    
  ],
  'avatar_uuid' => '',
  'chamber_of_commerce_number' => '',
  'country' => '',
  'legal_form' => '',
  'name' => '',
  'signup_track_type' => '',
  'subscription_type' => '',
  'ubo' => [
    [
        'date_of_birth' => '',
        'name' => '',
        'nationality' => ''
    ]
  ],
  'vat_number' => [
    'country' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'address_main' => [
    'city' => '',
    'country' => '',
    'extra' => '',
    'house_number' => '',
    'is_user_address_updated' => null,
    'mailbox_name' => '',
    'po_box' => '',
    'postal_code' => '',
    'province' => '',
    'street' => ''
  ],
  'address_postal' => [
    
  ],
  'avatar_uuid' => '',
  'chamber_of_commerce_number' => '',
  'country' => '',
  'legal_form' => '',
  'name' => '',
  'signup_track_type' => '',
  'subscription_type' => '',
  'ubo' => [
    [
        'date_of_birth' => '',
        'name' => '',
        'nationality' => ''
    ]
  ],
  'vat_number' => [
    'country' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/company');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/company' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/company' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/company", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/company"

payload = {
    "address_main": {
        "city": "",
        "country": "",
        "extra": "",
        "house_number": "",
        "is_user_address_updated": False,
        "mailbox_name": "",
        "po_box": "",
        "postal_code": "",
        "province": "",
        "street": ""
    },
    "address_postal": {},
    "avatar_uuid": "",
    "chamber_of_commerce_number": "",
    "country": "",
    "legal_form": "",
    "name": "",
    "signup_track_type": "",
    "subscription_type": "",
    "ubo": [
        {
            "date_of_birth": "",
            "name": "",
            "nationality": ""
        }
    ],
    "vat_number": {
        "country": "",
        "value": ""
    }
}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/company"

payload <- "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/company")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/user/:userID/company') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/company";

    let payload = json!({
        "address_main": json!({
            "city": "",
            "country": "",
            "extra": "",
            "house_number": "",
            "is_user_address_updated": false,
            "mailbox_name": "",
            "po_box": "",
            "postal_code": "",
            "province": "",
            "street": ""
        }),
        "address_postal": json!({}),
        "avatar_uuid": "",
        "chamber_of_commerce_number": "",
        "country": "",
        "legal_form": "",
        "name": "",
        "signup_track_type": "",
        "subscription_type": "",
        "ubo": (
            json!({
                "date_of_birth": "",
                "name": "",
                "nationality": ""
            })
        ),
        "vat_number": json!({
            "country": "",
            "value": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}' |  \
  http POST {{baseUrl}}/user/:userID/company \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "address_main": {\n    "city": "",\n    "country": "",\n    "extra": "",\n    "house_number": "",\n    "is_user_address_updated": false,\n    "mailbox_name": "",\n    "po_box": "",\n    "postal_code": "",\n    "province": "",\n    "street": ""\n  },\n  "address_postal": {},\n  "avatar_uuid": "",\n  "chamber_of_commerce_number": "",\n  "country": "",\n  "legal_form": "",\n  "name": "",\n  "signup_track_type": "",\n  "subscription_type": "",\n  "ubo": [\n    {\n      "date_of_birth": "",\n      "name": "",\n      "nationality": ""\n    }\n  ],\n  "vat_number": {\n    "country": "",\n    "value": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/company

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [
  "address_main": [
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  ],
  "address_postal": [],
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    [
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    ]
  ],
  "vat_number": [
    "country": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/company")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/company");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/company" {:headers {:user-agent ""
                                                                          :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/company"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/company"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/company");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/company"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/company HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/company")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/company"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/company")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/company")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/company');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/company',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/company';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/company',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/company")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/company',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/company',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/company');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/company',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/company';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/company"]
                                                       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}}/user/:userID/company" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/company",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/company', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/company');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/company');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/company' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/company' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/company", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/company"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/company"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/company")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/company') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/company";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/company \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/company

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/company")! 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}}/user/:userID/company/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/company/:itemId" {:headers {:user-agent ""
                                                                                  :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/company/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/company/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/company/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/company/:itemId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/company/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/company/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/company/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/company/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/company/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/company/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/company/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/company/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/company/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/company/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/company/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/company/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/company/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/company/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/company/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/company/:itemId"]
                                                       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}}/user/:userID/company/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/company/:itemId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/company/:itemId', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/company/:itemId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/company/:itemId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/company/:itemId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/company/:itemId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/company/:itemId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/company/:itemId"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/company/:itemId"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/company/:itemId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/company/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/company/:itemId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/company/:itemId \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/company/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/company/:itemId")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/company/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/user/:userID/company/:itemId" {:headers {:user-agent ""
                                                                                  :x-bunq-client-authentication ""}
                                                                        :content-type :json
                                                                        :form-params {:address_main {:city ""
                                                                                                     :country ""
                                                                                                     :extra ""
                                                                                                     :house_number ""
                                                                                                     :is_user_address_updated false
                                                                                                     :mailbox_name ""
                                                                                                     :po_box ""
                                                                                                     :postal_code ""
                                                                                                     :province ""
                                                                                                     :street ""}
                                                                                      :address_postal {}
                                                                                      :avatar_uuid ""
                                                                                      :chamber_of_commerce_number ""
                                                                                      :country ""
                                                                                      :legal_form ""
                                                                                      :name ""
                                                                                      :signup_track_type ""
                                                                                      :subscription_type ""
                                                                                      :ubo [{:date_of_birth ""
                                                                                             :name ""
                                                                                             :nationality ""}]
                                                                                      :vat_number {:country ""
                                                                                                   :value ""}}})

require "http/client"

url = "{{baseUrl}}/user/:userID/company/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\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}}/user/:userID/company/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\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}}/user/:userID/company/:itemId");
var request = new RestRequest("", Method.Put);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/company/:itemId"

	payload := strings.NewReader("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/company/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 584

{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/user/:userID/company/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/company/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/company/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/user/:userID/company/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  address_main: {
    city: '',
    country: '',
    extra: '',
    house_number: '',
    is_user_address_updated: false,
    mailbox_name: '',
    po_box: '',
    postal_code: '',
    province: '',
    street: ''
  },
  address_postal: {},
  avatar_uuid: '',
  chamber_of_commerce_number: '',
  country: '',
  legal_form: '',
  name: '',
  signup_track_type: '',
  subscription_type: '',
  ubo: [
    {
      date_of_birth: '',
      name: '',
      nationality: ''
    }
  ],
  vat_number: {
    country: '',
    value: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/user/:userID/company/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/company/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    address_main: {
      city: '',
      country: '',
      extra: '',
      house_number: '',
      is_user_address_updated: false,
      mailbox_name: '',
      po_box: '',
      postal_code: '',
      province: '',
      street: ''
    },
    address_postal: {},
    avatar_uuid: '',
    chamber_of_commerce_number: '',
    country: '',
    legal_form: '',
    name: '',
    signup_track_type: '',
    subscription_type: '',
    ubo: [{date_of_birth: '', name: '', nationality: ''}],
    vat_number: {country: '', value: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/company/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"address_main":{"city":"","country":"","extra":"","house_number":"","is_user_address_updated":false,"mailbox_name":"","po_box":"","postal_code":"","province":"","street":""},"address_postal":{},"avatar_uuid":"","chamber_of_commerce_number":"","country":"","legal_form":"","name":"","signup_track_type":"","subscription_type":"","ubo":[{"date_of_birth":"","name":"","nationality":""}],"vat_number":{"country":"","value":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/company/:itemId',
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address_main": {\n    "city": "",\n    "country": "",\n    "extra": "",\n    "house_number": "",\n    "is_user_address_updated": false,\n    "mailbox_name": "",\n    "po_box": "",\n    "postal_code": "",\n    "province": "",\n    "street": ""\n  },\n  "address_postal": {},\n  "avatar_uuid": "",\n  "chamber_of_commerce_number": "",\n  "country": "",\n  "legal_form": "",\n  "name": "",\n  "signup_track_type": "",\n  "subscription_type": "",\n  "ubo": [\n    {\n      "date_of_birth": "",\n      "name": "",\n      "nationality": ""\n    }\n  ],\n  "vat_number": {\n    "country": "",\n    "value": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/company/:itemId")
  .put(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/company/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  address_main: {
    city: '',
    country: '',
    extra: '',
    house_number: '',
    is_user_address_updated: false,
    mailbox_name: '',
    po_box: '',
    postal_code: '',
    province: '',
    street: ''
  },
  address_postal: {},
  avatar_uuid: '',
  chamber_of_commerce_number: '',
  country: '',
  legal_form: '',
  name: '',
  signup_track_type: '',
  subscription_type: '',
  ubo: [{date_of_birth: '', name: '', nationality: ''}],
  vat_number: {country: '', value: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/company/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    address_main: {
      city: '',
      country: '',
      extra: '',
      house_number: '',
      is_user_address_updated: false,
      mailbox_name: '',
      po_box: '',
      postal_code: '',
      province: '',
      street: ''
    },
    address_postal: {},
    avatar_uuid: '',
    chamber_of_commerce_number: '',
    country: '',
    legal_form: '',
    name: '',
    signup_track_type: '',
    subscription_type: '',
    ubo: [{date_of_birth: '', name: '', nationality: ''}],
    vat_number: {country: '', value: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/user/:userID/company/:itemId');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  address_main: {
    city: '',
    country: '',
    extra: '',
    house_number: '',
    is_user_address_updated: false,
    mailbox_name: '',
    po_box: '',
    postal_code: '',
    province: '',
    street: ''
  },
  address_postal: {},
  avatar_uuid: '',
  chamber_of_commerce_number: '',
  country: '',
  legal_form: '',
  name: '',
  signup_track_type: '',
  subscription_type: '',
  ubo: [
    {
      date_of_birth: '',
      name: '',
      nationality: ''
    }
  ],
  vat_number: {
    country: '',
    value: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user/:userID/company/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    address_main: {
      city: '',
      country: '',
      extra: '',
      house_number: '',
      is_user_address_updated: false,
      mailbox_name: '',
      po_box: '',
      postal_code: '',
      province: '',
      street: ''
    },
    address_postal: {},
    avatar_uuid: '',
    chamber_of_commerce_number: '',
    country: '',
    legal_form: '',
    name: '',
    signup_track_type: '',
    subscription_type: '',
    ubo: [{date_of_birth: '', name: '', nationality: ''}],
    vat_number: {country: '', value: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/company/:itemId';
const options = {
  method: 'PUT',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"address_main":{"city":"","country":"","extra":"","house_number":"","is_user_address_updated":false,"mailbox_name":"","po_box":"","postal_code":"","province":"","street":""},"address_postal":{},"avatar_uuid":"","chamber_of_commerce_number":"","country":"","legal_form":"","name":"","signup_track_type":"","subscription_type":"","ubo":[{"date_of_birth":"","name":"","nationality":""}],"vat_number":{"country":"","value":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"address_main": @{ @"city": @"", @"country": @"", @"extra": @"", @"house_number": @"", @"is_user_address_updated": @NO, @"mailbox_name": @"", @"po_box": @"", @"postal_code": @"", @"province": @"", @"street": @"" },
                              @"address_postal": @{  },
                              @"avatar_uuid": @"",
                              @"chamber_of_commerce_number": @"",
                              @"country": @"",
                              @"legal_form": @"",
                              @"name": @"",
                              @"signup_track_type": @"",
                              @"subscription_type": @"",
                              @"ubo": @[ @{ @"date_of_birth": @"", @"name": @"", @"nationality": @"" } ],
                              @"vat_number": @{ @"country": @"", @"value": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/company/:itemId"]
                                                       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}}/user/:userID/company/:itemId" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/company/:itemId",
  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([
    'address_main' => [
        'city' => '',
        'country' => '',
        'extra' => '',
        'house_number' => '',
        'is_user_address_updated' => null,
        'mailbox_name' => '',
        'po_box' => '',
        'postal_code' => '',
        'province' => '',
        'street' => ''
    ],
    'address_postal' => [
        
    ],
    'avatar_uuid' => '',
    'chamber_of_commerce_number' => '',
    'country' => '',
    'legal_form' => '',
    'name' => '',
    'signup_track_type' => '',
    'subscription_type' => '',
    'ubo' => [
        [
                'date_of_birth' => '',
                'name' => '',
                'nationality' => ''
        ]
    ],
    'vat_number' => [
        'country' => '',
        'value' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/user/:userID/company/:itemId', [
  'body' => '{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/company/:itemId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address_main' => [
    'city' => '',
    'country' => '',
    'extra' => '',
    'house_number' => '',
    'is_user_address_updated' => null,
    'mailbox_name' => '',
    'po_box' => '',
    'postal_code' => '',
    'province' => '',
    'street' => ''
  ],
  'address_postal' => [
    
  ],
  'avatar_uuid' => '',
  'chamber_of_commerce_number' => '',
  'country' => '',
  'legal_form' => '',
  'name' => '',
  'signup_track_type' => '',
  'subscription_type' => '',
  'ubo' => [
    [
        'date_of_birth' => '',
        'name' => '',
        'nationality' => ''
    ]
  ],
  'vat_number' => [
    'country' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'address_main' => [
    'city' => '',
    'country' => '',
    'extra' => '',
    'house_number' => '',
    'is_user_address_updated' => null,
    'mailbox_name' => '',
    'po_box' => '',
    'postal_code' => '',
    'province' => '',
    'street' => ''
  ],
  'address_postal' => [
    
  ],
  'avatar_uuid' => '',
  'chamber_of_commerce_number' => '',
  'country' => '',
  'legal_form' => '',
  'name' => '',
  'signup_track_type' => '',
  'subscription_type' => '',
  'ubo' => [
    [
        'date_of_birth' => '',
        'name' => '',
        'nationality' => ''
    ]
  ],
  'vat_number' => [
    'country' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/company/:itemId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/company/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/company/:itemId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/user/:userID/company/:itemId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/company/:itemId"

payload = {
    "address_main": {
        "city": "",
        "country": "",
        "extra": "",
        "house_number": "",
        "is_user_address_updated": False,
        "mailbox_name": "",
        "po_box": "",
        "postal_code": "",
        "province": "",
        "street": ""
    },
    "address_postal": {},
    "avatar_uuid": "",
    "chamber_of_commerce_number": "",
    "country": "",
    "legal_form": "",
    "name": "",
    "signup_track_type": "",
    "subscription_type": "",
    "ubo": [
        {
            "date_of_birth": "",
            "name": "",
            "nationality": ""
        }
    ],
    "vat_number": {
        "country": "",
        "value": ""
    }
}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/company/:itemId"

payload <- "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/company/:itemId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\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/user/:userID/company/:itemId') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"address_main\": {\n    \"city\": \"\",\n    \"country\": \"\",\n    \"extra\": \"\",\n    \"house_number\": \"\",\n    \"is_user_address_updated\": false,\n    \"mailbox_name\": \"\",\n    \"po_box\": \"\",\n    \"postal_code\": \"\",\n    \"province\": \"\",\n    \"street\": \"\"\n  },\n  \"address_postal\": {},\n  \"avatar_uuid\": \"\",\n  \"chamber_of_commerce_number\": \"\",\n  \"country\": \"\",\n  \"legal_form\": \"\",\n  \"name\": \"\",\n  \"signup_track_type\": \"\",\n  \"subscription_type\": \"\",\n  \"ubo\": [\n    {\n      \"date_of_birth\": \"\",\n      \"name\": \"\",\n      \"nationality\": \"\"\n    }\n  ],\n  \"vat_number\": {\n    \"country\": \"\",\n    \"value\": \"\"\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}}/user/:userID/company/:itemId";

    let payload = json!({
        "address_main": json!({
            "city": "",
            "country": "",
            "extra": "",
            "house_number": "",
            "is_user_address_updated": false,
            "mailbox_name": "",
            "po_box": "",
            "postal_code": "",
            "province": "",
            "street": ""
        }),
        "address_postal": json!({}),
        "avatar_uuid": "",
        "chamber_of_commerce_number": "",
        "country": "",
        "legal_form": "",
        "name": "",
        "signup_track_type": "",
        "subscription_type": "",
        "ubo": (
            json!({
                "date_of_birth": "",
                "name": "",
                "nationality": ""
            })
        ),
        "vat_number": json!({
            "country": "",
            "value": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".parse().unwrap());
    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 '{
  "address_main": {
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  },
  "address_postal": {},
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    {
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    }
  ],
  "vat_number": {
    "country": "",
    "value": ""
  }
}' |  \
  http PUT {{baseUrl}}/user/:userID/company/:itemId \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method PUT \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "address_main": {\n    "city": "",\n    "country": "",\n    "extra": "",\n    "house_number": "",\n    "is_user_address_updated": false,\n    "mailbox_name": "",\n    "po_box": "",\n    "postal_code": "",\n    "province": "",\n    "street": ""\n  },\n  "address_postal": {},\n  "avatar_uuid": "",\n  "chamber_of_commerce_number": "",\n  "country": "",\n  "legal_form": "",\n  "name": "",\n  "signup_track_type": "",\n  "subscription_type": "",\n  "ubo": [\n    {\n      "date_of_birth": "",\n      "name": "",\n      "nationality": ""\n    }\n  ],\n  "vat_number": {\n    "country": "",\n    "value": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/company/:itemId

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [
  "address_main": [
    "city": "",
    "country": "",
    "extra": "",
    "house_number": "",
    "is_user_address_updated": false,
    "mailbox_name": "",
    "po_box": "",
    "postal_code": "",
    "province": "",
    "street": ""
  ],
  "address_postal": [],
  "avatar_uuid": "",
  "chamber_of_commerce_number": "",
  "country": "",
  "legal_form": "",
  "name": "",
  "signup_track_type": "",
  "subscription_type": "",
  "ubo": [
    [
      "date_of_birth": "",
      "name": "",
      "nationality": ""
    ]
  ],
  "vat_number": [
    "country": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/company/:itemId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/:userID/confirmation-of-funds");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/user/:userID/confirmation-of-funds" {:headers {:user-agent ""
                                                                                         :x-bunq-client-authentication ""}
                                                                               :content-type :json
                                                                               :form-params {:amount {:currency ""
                                                                                                      :value ""}
                                                                                             :pointer_iban {:name ""
                                                                                                            :service ""
                                                                                                            :type ""
                                                                                                            :value ""}}})

require "http/client"

url = "{{baseUrl}}/user/:userID/confirmation-of-funds"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/user/:userID/confirmation-of-funds"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
    Content = new StringContent("{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\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}}/user/:userID/confirmation-of-funds");
var request = new RestRequest("", Method.Post);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/confirmation-of-funds"

	payload := strings.NewReader("{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")
	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/user/:userID/confirmation-of-funds HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Content-Type: application/json
Host: example.com
Content-Length: 149

{
  "amount": {
    "currency": "",
    "value": ""
  },
  "pointer_iban": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/user/:userID/confirmation-of-funds")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/confirmation-of-funds"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\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  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user/:userID/confirmation-of-funds")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/user/:userID/confirmation-of-funds")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .header("content-type", "application/json")
  .body("{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  amount: {
    currency: '',
    value: ''
  },
  pointer_iban: {
    name: '',
    service: '',
    type: '',
    value: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/user/:userID/confirmation-of-funds');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/confirmation-of-funds',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    amount: {currency: '', value: ''},
    pointer_iban: {name: '', service: '', type: '', value: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/confirmation-of-funds';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"amount":{"currency":"","value":""},"pointer_iban":{"name":"","service":"","type":"","value":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/:userID/confirmation-of-funds',
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "amount": {\n    "currency": "",\n    "value": ""\n  },\n  "pointer_iban": {\n    "name": "",\n    "service": "",\n    "type": "",\n    "value": ""\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  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/confirmation-of-funds")
  .post(body)
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .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/user/:userID/confirmation-of-funds',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    '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({
  amount: {currency: '', value: ''},
  pointer_iban: {name: '', service: '', type: '', value: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/confirmation-of-funds',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: {
    amount: {currency: '', value: ''},
    pointer_iban: {name: '', service: '', type: '', value: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/user/:userID/confirmation-of-funds');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  amount: {
    currency: '',
    value: ''
  },
  pointer_iban: {
    name: '',
    service: '',
    type: '',
    value: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/user/:userID/confirmation-of-funds',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  data: {
    amount: {currency: '', value: ''},
    pointer_iban: {name: '', service: '', type: '', value: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/confirmation-of-funds';
const options = {
  method: 'POST',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': '',
    'content-type': 'application/json'
  },
  body: '{"amount":{"currency":"","value":""},"pointer_iban":{"name":"","service":"","type":"","value":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"amount": @{ @"currency": @"", @"value": @"" },
                              @"pointer_iban": @{ @"name": @"", @"service": @"", @"type": @"", @"value": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/confirmation-of-funds"]
                                                       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}}/user/:userID/confirmation-of-funds" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/confirmation-of-funds",
  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([
    'amount' => [
        'currency' => '',
        'value' => ''
    ],
    'pointer_iban' => [
        'name' => '',
        'service' => '',
        'type' => '',
        'value' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/user/:userID/confirmation-of-funds', [
  'body' => '{
  "amount": {
    "currency": "",
    "value": ""
  },
  "pointer_iban": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/confirmation-of-funds');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'amount' => [
    'currency' => '',
    'value' => ''
  ],
  'pointer_iban' => [
    'name' => '',
    'service' => '',
    'type' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'amount' => [
    'currency' => '',
    'value' => ''
  ],
  'pointer_iban' => [
    'name' => '',
    'service' => '',
    'type' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/user/:userID/confirmation-of-funds');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/confirmation-of-funds' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": {
    "currency": "",
    "value": ""
  },
  "pointer_iban": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  }
}'

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/confirmation-of-funds' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": {
    "currency": "",
    "value": ""
  },
  "pointer_iban": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}"

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/user/:userID/confirmation-of-funds", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/confirmation-of-funds"

payload = {
    "amount": {
        "currency": "",
        "value": ""
    },
    "pointer_iban": {
        "name": "",
        "service": "",
        "type": "",
        "value": ""
    }
}
headers = {
    "user-agent": "",
    "x-bunq-client-authentication": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/confirmation-of-funds"

payload <- "{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/confirmation-of-funds")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/user/:userID/confirmation-of-funds') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
  req.body = "{\n  \"amount\": {\n    \"currency\": \"\",\n    \"value\": \"\"\n  },\n  \"pointer_iban\": {\n    \"name\": \"\",\n    \"service\": \"\",\n    \"type\": \"\",\n    \"value\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/confirmation-of-funds";

    let payload = json!({
        "amount": json!({
            "currency": "",
            "value": ""
        }),
        "pointer_iban": json!({
            "name": "",
            "service": "",
            "type": "",
            "value": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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 '{
  "amount": {
    "currency": "",
    "value": ""
  },
  "pointer_iban": {
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  }
}' |  \
  http POST {{baseUrl}}/user/:userID/confirmation-of-funds \
  content-type:application/json \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method POST \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "amount": {\n    "currency": "",\n    "value": ""\n  },\n  "pointer_iban": {\n    "name": "",\n    "service": "",\n    "type": "",\n    "value": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/user/:userID/confirmation-of-funds

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": "",
  "content-type": "application/json"
]
let parameters = [
  "amount": [
    "currency": "",
    "value": ""
  ],
  "pointer_iban": [
    "name": "",
    "service": "",
    "type": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/confirmation-of-funds")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/attachment-public/:attachment-publicUUID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/attachment-public/:attachment-publicUUID/content" {:headers {:user-agent ""
                                                                                                      :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/attachment-public/:attachment-publicUUID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/attachment-public/:attachment-publicUUID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/attachment-public/:attachment-publicUUID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/attachment-public/:attachment-publicUUID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/attachment-public/:attachment-publicUUID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/attachment-public/:attachment-publicUUID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/attachment-public/:attachment-publicUUID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/attachment-public/:attachment-publicUUID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/attachment-public/:attachment-publicUUID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/attachment-public/:attachment-publicUUID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/attachment-public/:attachment-publicUUID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/attachment-public/:attachment-publicUUID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/attachment-public/:attachment-publicUUID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/attachment-public/:attachment-publicUUID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/attachment-public/:attachment-publicUUID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/attachment-public/:attachment-publicUUID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/attachment-public/:attachment-publicUUID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/attachment-public/:attachment-publicUUID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/attachment-public/:attachment-publicUUID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/attachment-public/:attachment-publicUUID/content"]
                                                       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}}/attachment-public/:attachment-publicUUID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/attachment-public/:attachment-publicUUID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/attachment-public/:attachment-publicUUID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/attachment-public/:attachment-publicUUID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/attachment-public/:attachment-publicUUID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/attachment-public/:attachment-publicUUID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/attachment-public/:attachment-publicUUID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/attachment-public/:attachment-publicUUID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/attachment-public/:attachment-publicUUID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/attachment-public/:attachment-publicUUID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/attachment-public/:attachment-publicUUID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/attachment-public/:attachment-publicUUID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/attachment-public/:attachment-publicUUID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/attachment-public/:attachment-publicUUID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/attachment-public/:attachment-publicUUID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/attachment-public/:attachment-publicUUID/content")! 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}}/place-lookup/:place-lookupID/photo/:photoID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content" {:headers {:user-agent ""
                                                                                                         :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/place-lookup/:place-lookupID/photo/:photoID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/place-lookup/:place-lookupID/photo/:photoID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/place-lookup/:place-lookupID/photo/:photoID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/place-lookup/:place-lookupID/photo/:photoID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/place-lookup/:place-lookupID/photo/:photoID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/place-lookup/:place-lookupID/photo/:photoID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/place-lookup/:place-lookupID/photo/:photoID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/place-lookup/:place-lookupID/photo/:photoID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content"]
                                                       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}}/place-lookup/:place-lookupID/photo/:photoID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/place-lookup/:place-lookupID/photo/:photoID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/place-lookup/:place-lookupID/photo/:photoID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/place-lookup/:place-lookupID/photo/:photoID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/place-lookup/:place-lookupID/photo/:photoID/content")! 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}}/user/:userID/attachment/:attachmentID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/attachment/:attachmentID/content" {:headers {:user-agent ""
                                                                                                   :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/attachment/:attachmentID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/attachment/:attachmentID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/attachment/:attachmentID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/attachment/:attachmentID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/attachment/:attachmentID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/attachment/:attachmentID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/attachment/:attachmentID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/attachment/:attachmentID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/attachment/:attachmentID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/attachment/:attachmentID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/attachment/:attachmentID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/attachment/:attachmentID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/attachment/:attachmentID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/attachment/:attachmentID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/attachment/:attachmentID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/attachment/:attachmentID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/attachment/:attachmentID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/attachment/:attachmentID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/attachment/:attachmentID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/attachment/:attachmentID/content"]
                                                       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}}/user/:userID/attachment/:attachmentID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/attachment/:attachmentID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/attachment/:attachmentID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/attachment/:attachmentID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/attachment/:attachmentID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/attachment/:attachmentID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/attachment/:attachmentID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/attachment/:attachmentID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/attachment/:attachmentID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/attachment/:attachmentID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/attachment/:attachmentID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/attachment/:attachmentID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/attachment/:attachmentID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/attachment/:attachmentID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/attachment/:attachmentID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/attachment/:attachmentID/content")! 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}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content" {:headers {:user-agent ""
                                                                                                                                      :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content"]
                                                       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}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/card/:cardID/export-statement-card/:export-statement-cardID/content")! 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}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content" {:headers {:user-agent ""
                                                                                                                                          :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content"]
                                                       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}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/chat-conversation/:chat-conversationID/attachment/:attachmentID/content")! 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}}/user/:userID/export-annual-overview/:export-annual-overviewID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content" {:headers {:user-agent ""
                                                                                                                           :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/export-annual-overview/:export-annual-overviewID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/export-annual-overview/:export-annual-overviewID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/export-annual-overview/:export-annual-overviewID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/export-annual-overview/:export-annual-overviewID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/export-annual-overview/:export-annual-overviewID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/export-annual-overview/:export-annual-overviewID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/export-annual-overview/:export-annual-overviewID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/export-annual-overview/:export-annual-overviewID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content"]
                                                       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}}/user/:userID/export-annual-overview/:export-annual-overviewID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/export-annual-overview/:export-annual-overviewID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/export-annual-overview/:export-annual-overviewID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/export-annual-overview/:export-annual-overviewID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/export-annual-overview/:export-annual-overviewID/content")! 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}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content" {:headers {:user-agent ""
                                                                                                                                        :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/attachment/:attachmentID/content")! 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}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content" {:headers {:user-agent ""
                                                                                                                                                        :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/customer-statement/:customer-statementID/content")! 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}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content" {:headers {:user-agent ""
                                                                                                                                                     :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/event/:eventID/statement/:statementID/content")! 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}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content" {:headers {:user-agent ""
                                                                                                                                        :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content"]
                                                       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}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/monetary-account/:monetary-accountID/export-rib/:export-ribID/content")! 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}}/user/:userID/credential-password-ip");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/credential-password-ip" {:headers {:user-agent ""
                                                                                         :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/credential-password-ip"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/credential-password-ip"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/credential-password-ip");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/credential-password-ip"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/credential-password-ip HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/credential-password-ip")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/credential-password-ip"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/credential-password-ip")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/credential-password-ip")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/credential-password-ip');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/credential-password-ip',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/credential-password-ip';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/credential-password-ip',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/credential-password-ip")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/credential-password-ip',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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}}/user/:userID/credential-password-ip',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/:userID/credential-password-ip');

req.headers({
  'user-agent': '',
  'x-bunq-client-authentication': ''
});

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}}/user/:userID/credential-password-ip',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/:userID/credential-password-ip';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user-agent": @"",
                           @"x-bunq-client-authentication": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/:userID/credential-password-ip"]
                                                       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}}/user/:userID/credential-password-ip" in
let headers = Header.add_list (Header.init ()) [
  ("user-agent", "");
  ("x-bunq-client-authentication", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/:userID/credential-password-ip",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user-agent: ",
    "x-bunq-client-authentication: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user/:userID/credential-password-ip', [
  'headers' => [
    'user-agent' => '',
    'x-bunq-client-authentication' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user/:userID/credential-password-ip');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/:userID/credential-password-ip');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user-agent' => '',
  'x-bunq-client-authentication' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/:userID/credential-password-ip' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user-agent", "")
$headers.Add("x-bunq-client-authentication", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/:userID/credential-password-ip' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'user-agent': "",
    'x-bunq-client-authentication': ""
}

conn.request("GET", "/baseUrl/user/:userID/credential-password-ip", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/:userID/credential-password-ip"

headers = {
    "user-agent": "",
    "x-bunq-client-authentication": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/:userID/credential-password-ip"

response <- VERB("GET", url, add_headers('user-agent' = '', 'x-bunq-client-authentication' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/:userID/credential-password-ip")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user-agent"] = ''
request["x-bunq-client-authentication"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/:userID/credential-password-ip') do |req|
  req.headers['user-agent'] = ''
  req.headers['x-bunq-client-authentication'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/:userID/credential-password-ip";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user-agent", "".parse().unwrap());
    headers.insert("x-bunq-client-authentication", "".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}}/user/:userID/credential-password-ip \
  user-agent:'' \
  x-bunq-client-authentication:''

wget --quiet \
  --method GET \
  --header 'user-agent: ' \
  --header 'x-bunq-client-authentication: ' \
  --output-document \
  - {{baseUrl}}/user/:userID/credential-password-ip

import Foundation

let headers = [
  "user-agent": "",
  "x-bunq-client-authentication": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/:userID/credential-password-ip")! 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}}/user/:userID/credential-password-ip/:itemId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user-agent: ");
headers = curl_slist_append(headers, "x-bunq-client-authentication: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/:userID/credential-password-ip/:itemId" {:headers {:user-agent ""
                                                                                                 :x-bunq-client-authentication ""}})

require "http/client"

url = "{{baseUrl}}/user/:userID/credential-password-ip/:itemId"
headers = HTTP::Headers{
  "user-agent" => ""
  "x-bunq-client-authentication" => ""
}

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}}/user/:userID/credential-password-ip/:itemId"),
    Headers =
    {
        { "user-agent", "" },
        { "x-bunq-client-authentication", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/:userID/credential-password-ip/:itemId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user-agent", "");
request.AddHeader("x-bunq-client-authentication", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/:userID/credential-password-ip/:itemId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user-agent", "")
	req.Header.Add("x-bunq-client-authentication", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/:userID/credential-password-ip/:itemId HTTP/1.1
User-Agent: 
X-Bunq-Client-Authentication: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/:userID/credential-password-ip/:itemId")
  .setHeader("user-agent", "")
  .setHeader("x-bunq-client-authentication", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/:userID/credential-password-ip/:itemId"))
    .header("user-agent", "")
    .header("x-bunq-client-authentication", "")
    .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}}/user/:userID/credential-password-ip/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/:userID/credential-password-ip/:itemId")
  .header("user-agent", "")
  .header("x-bunq-client-authentication", "")
  .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}}/user/:userID/credential-password-ip/:itemId');
xhr.setRequestHeader('user-agent', '');
xhr.setRequestHeader('x-bunq-client-authentication', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/:userID/credential-password-ip/:itemId',
  headers: {'user-agent': '', 'x-bunq-client-authentication': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/:userID/credential-password-ip/:itemId';
const options = {method: 'GET', headers: {'user-agent': '', 'x-bunq-client-authentication': ''}};

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}}/user/:userID/credential-password-ip/:itemId',
  method: 'GET',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/:userID/credential-password-ip/:itemId")
  .get()
  .addHeader("user-agent", "")
  .addHeader("x-bunq-client-authentication", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/:userID/credential-password-ip/:itemId',
  headers: {
    'user-agent': '',
    'x-bunq-client-authentication': ''
  }
};

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();