Customer Credit APIv1.0

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements" {:headers {:content-type ""
                                                                                                            :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

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

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

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

}

GET /baseUrl/api/creditcontrol/accounts/:creditAccountId/statements HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/accounts/:creditAccountId/statements")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/accounts/:creditAccountId/statements');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/accounts/:creditAccountId/statements',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/statements',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/accounts/:creditAccountId/statements',
  headers: {'content-type': '', accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements');

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/accounts/:creditAccountId/statements',
  headers: {'content-type': '', accept: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements' -Method GET -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/statements", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements"

headers = {
    "content-type": "",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements")

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

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/api/creditcontrol/accounts/:creditAccountId/statements') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/accounts/:creditAccountId/statements \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders" {:headers {:accept ""}
                                                                                                :content-type :json
                                                                                                :form-params {:claims {:email ""}}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"claims\": {\n    \"email\": \"\"\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}}/api/creditcontrol/accounts/:creditAccountId/holders"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"claims\": {\n    \"email\": \"\"\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}}/api/creditcontrol/accounts/:creditAccountId/holders");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders"

	payload := strings.NewReader("{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}")

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

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/api/creditcontrol/accounts/:creditAccountId/holders HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 37

{
  "claims": {
    "email": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders"))
    .header("accept", "")
    .header("content-type", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"claims\": {\n    \"email\": \"\"\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  \"claims\": {\n    \"email\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  claims: {
    email: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders',
  headers: {accept: '', 'content-type': ''},
  data: {claims: {email: ''}}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"claims":{"email":""}}'
};

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}}/api/creditcontrol/accounts/:creditAccountId/holders',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "claims": {\n    "email": ""\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  \"claims\": {\n    \"email\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/holders',
  headers: {
    accept: '',
    'content-type': ''
  }
};

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({claims: {email: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders',
  headers: {accept: '', 'content-type': ''},
  body: {claims: {email: ''}},
  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}}/api/creditcontrol/accounts/:creditAccountId/holders');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  claims: {
    email: ''
  }
});

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}}/api/creditcontrol/accounts/:creditAccountId/holders',
  headers: {accept: '', 'content-type': ''},
  data: {claims: {email: ''}}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"claims":{"email":""}}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"claims": @{ @"email": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/holders" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders",
  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([
    'claims' => [
        'email' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders', [
  'body' => '{
  "claims": {
    "email": ""
  }
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

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

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

append(json_encode([
  'claims' => [
    'email' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders' -Method POST -Headers $headers -ContentType '' -Body '{
  "claims": {
    "email": ""
  }
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders' -Method POST -Headers $headers -ContentType '' -Body '{
  "claims": {
    "email": ""
  }
}'

import http.client

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

payload = "{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/holders", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders"

payload = { "claims": { "email": "" } }
headers = {
    "accept": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders"

payload <- "{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders")

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

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/api/creditcontrol/accounts/:creditAccountId/holders') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"claims\": {\n    \"email\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"claims": json!({"email": ""})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".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 '{
  "claims": {
    "email": ""
  }
}' |  \
  http POST {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "claims": {\n    "email": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = ["claims": ["email": ""]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders")! 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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId" {:headers {:content-type ""
                                                                                                                                :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

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

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

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

}

DELETE /baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")
  .delete(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId';
const options = {method: 'DELETE', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  method: 'DELETE',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")
  .delete(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  headers: {'content-type': '', accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId');

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  headers: {'content-type': '', accept: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId';
const options = {method: 'DELETE', headers: {'content-type': '', accept: ''}};

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

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("DELETE", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"

headers = {
    "content-type": "",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")

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

request = Net::HTTP::Delete.new(url)
request["content-type"] = ''
request["accept"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId \
  accept:'' \
  content-type:''

wget --quiet \
  --method DELETE \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"value\": 10000\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit" {:headers {:accept ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:value 10000}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"value\": 10000\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}}/api/creditcontrol/accounts/:creditAccountId/creditlimit"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"value\": 10000\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}}/api/creditcontrol/accounts/:creditAccountId/creditlimit");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"value\": 10000\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit"

	payload := strings.NewReader("{\n  \"value\": 10000\n}")

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

	req.Header.Add("accept", "")
	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/api/creditcontrol/accounts/:creditAccountId/creditlimit HTTP/1.1
Accept: 
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "value": 10000
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit")
  .setHeader("accept", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"value\": 10000\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit"))
    .header("accept", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"value\": 10000\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  \"value\": 10000\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit")
  .header("accept", "")
  .header("content-type", "application/json")
  .body("{\n  \"value\": 10000\n}")
  .asString();

const data = JSON.stringify({
  value: 10000
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {value: 10000}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"value":10000}'
};

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}}/api/creditcontrol/accounts/:creditAccountId/creditlimit',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "value": 10000\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"value\": 10000\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit")
  .put(body)
  .addHeader("accept", "")
  .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/api/creditcontrol/accounts/:creditAccountId/creditlimit',
  headers: {
    accept: '',
    '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({value: 10000}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit',
  headers: {accept: '', 'content-type': 'application/json'},
  body: {value: 10000},
  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}}/api/creditcontrol/accounts/:creditAccountId/creditlimit');

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

req.type('json');
req.send({
  value: 10000
});

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}}/api/creditcontrol/accounts/:creditAccountId/creditlimit',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {value: 10000}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"value":10000}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"value": @10000 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/creditlimit" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"value\": 10000\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit",
  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([
    'value' => 10000
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit', [
  'body' => '{
  "value": 10000
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'value' => 10000
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "value": 10000
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "value": 10000
}'

import http.client

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

payload = "{\n  \"value\": 10000\n}"

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

conn.request("PUT", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/creditlimit", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit"

payload = { "value": 10000 }
headers = {
    "accept": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit"

payload <- "{\n  \"value\": 10000\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit")

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

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"value\": 10000\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/api/creditcontrol/accounts/:creditAccountId/creditlimit') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"value\": 10000\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}}/api/creditcontrol/accounts/:creditAccountId/creditlimit";

    let payload = json!({"value": 10000});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".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 '{
  "value": 10000
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "value": 10000\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit

import Foundation

let headers = [
  "accept": "",
  "content-type": "application/json"
]
let parameters = ["value": 10000] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/creditlimit")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"value\": 0.2\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance" {:headers {:accept ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:value 0.2}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"value\": 0.2\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}}/api/creditcontrol/accounts/:creditAccountId/tolerance"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"value\": 0.2\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}}/api/creditcontrol/accounts/:creditAccountId/tolerance");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"value\": 0.2\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance"

	payload := strings.NewReader("{\n  \"value\": 0.2\n}")

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

	req.Header.Add("accept", "")
	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/api/creditcontrol/accounts/:creditAccountId/tolerance HTTP/1.1
Accept: 
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "value": 0.2
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance")
  .setHeader("accept", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"value\": 0.2\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance"))
    .header("accept", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"value\": 0.2\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  \"value\": 0.2\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance")
  .header("accept", "")
  .header("content-type", "application/json")
  .body("{\n  \"value\": 0.2\n}")
  .asString();

const data = JSON.stringify({
  value: 0.2
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {value: 0.2}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"value":0.2}'
};

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}}/api/creditcontrol/accounts/:creditAccountId/tolerance',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "value": 0.2\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"value\": 0.2\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance")
  .put(body)
  .addHeader("accept", "")
  .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/api/creditcontrol/accounts/:creditAccountId/tolerance',
  headers: {
    accept: '',
    '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({value: 0.2}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance',
  headers: {accept: '', 'content-type': 'application/json'},
  body: {value: 0.2},
  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}}/api/creditcontrol/accounts/:creditAccountId/tolerance');

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

req.type('json');
req.send({
  value: 0.2
});

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}}/api/creditcontrol/accounts/:creditAccountId/tolerance',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {value: 0.2}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"value":0.2}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"value": @0.2 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/tolerance" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"value\": 0.2\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance",
  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([
    'value' => 0.2
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance', [
  'body' => '{
  "value": 0.2
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'value' => 0.2
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "value": 0.2
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "value": 0.2
}'

import http.client

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

payload = "{\n  \"value\": 0.2\n}"

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

conn.request("PUT", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/tolerance", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance"

payload = { "value": 0.2 }
headers = {
    "accept": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance"

payload <- "{\n  \"value\": 0.2\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance")

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

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"value\": 0.2\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/api/creditcontrol/accounts/:creditAccountId/tolerance') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"value\": 0.2\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}}/api/creditcontrol/accounts/:creditAccountId/tolerance";

    let payload = json!({"value": 0.2});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".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 '{
  "value": 0.2
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "value": 0.2\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/tolerance

import Foundation

let headers = [
  "accept": "",
  "content-type": "application/json"
]
let parameters = ["value": 0.2] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId" {:headers {:accept ""}
                                                                                          :content-type :json
                                                                                          :form-params {:document "number"
                                                                                                        :documentType "CPF ou CNPJ ou Other"
                                                                                                        :email "email"}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\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}}/api/creditcontrol/accounts/:creditAccountId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"

	payload := strings.NewReader("{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}")

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

	req.Header.Add("accept", "")
	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))

}

DELETE /baseUrl/api/creditcontrol/accounts/:creditAccountId HTTP/1.1
Accept: 
Content-Type: application/json
Host: example.com
Content-Length: 88

{
  "document": "number",
  "documentType": "CPF ou CNPJ ou Other",
  "email": "email"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .setHeader("accept", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"))
    .header("accept", "")
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\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  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .delete(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .header("accept", "")
  .header("content-type", "application/json")
  .body("{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}")
  .asString();

const data = JSON.stringify({
  document: 'number',
  documentType: 'CPF ou CNPJ ou Other',
  email: 'email'
});

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

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

xhr.open('DELETE', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {document: 'number', documentType: 'CPF ou CNPJ ou Other', email: 'email'}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId';
const options = {
  method: 'DELETE',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"document":"number","documentType":"CPF ou CNPJ ou Other","email":"email"}'
};

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}}/api/creditcontrol/accounts/:creditAccountId',
  method: 'DELETE',
  headers: {
    accept: '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "document": "number",\n  "documentType": "CPF ou CNPJ ou Other",\n  "email": "email"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .delete(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId',
  headers: {
    accept: '',
    '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({document: 'number', documentType: 'CPF ou CNPJ ou Other', email: 'email'}));
req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId',
  headers: {accept: '', 'content-type': 'application/json'},
  body: {document: 'number', documentType: 'CPF ou CNPJ ou Other', email: 'email'},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId');

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

req.type('json');
req.send({
  document: 'number',
  documentType: 'CPF ou CNPJ ou Other',
  email: 'email'
});

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}}/api/creditcontrol/accounts/:creditAccountId',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {document: 'number', documentType: 'CPF ou CNPJ ou Other', email: 'email'}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId';
const options = {
  method: 'DELETE',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"document":"number","documentType":"CPF ou CNPJ ou Other","email":"email"}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"document": @"number",
                              @"documentType": @"CPF ou CNPJ ou Other",
                              @"email": @"email" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/api/creditcontrol/accounts/:creditAccountId" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_POSTFIELDS => json_encode([
    'document' => 'number',
    'documentType' => 'CPF ou CNPJ ou Other',
    'email' => 'email'
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId', [
  'body' => '{
  "document": "number",
  "documentType": "CPF ou CNPJ ou Other",
  "email": "email"
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId');
$request->setMethod(HTTP_METH_DELETE);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'document' => 'number',
  'documentType' => 'CPF ou CNPJ ou Other',
  'email' => 'email'
]));

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

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

append(json_encode([
  'document' => 'number',
  'documentType' => 'CPF ou CNPJ ou Other',
  'email' => 'email'
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId');
$request->setRequestMethod('DELETE');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "document": "number",
  "documentType": "CPF ou CNPJ ou Other",
  "email": "email"
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "document": "number",
  "documentType": "CPF ou CNPJ ou Other",
  "email": "email"
}'

import http.client

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

payload = "{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}"

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

conn.request("DELETE", "/baseUrl/api/creditcontrol/accounts/:creditAccountId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"

payload = {
    "document": "number",
    "documentType": "CPF ou CNPJ ou Other",
    "email": "email"
}
headers = {
    "accept": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"

payload <- "{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")

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

request = Net::HTTP::Delete.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\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.delete('/baseUrl/api/creditcontrol/accounts/:creditAccountId') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"document\": \"number\",\n  \"documentType\": \"CPF ou CNPJ ou Other\",\n  \"email\": \"email\"\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}}/api/creditcontrol/accounts/:creditAccountId";

    let payload = json!({
        "document": "number",
        "documentType": "CPF ou CNPJ ou Other",
        "email": "email"
    });

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

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

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

    dbg!(results);
}

echo '{
  "document": "number",
  "documentType": "CPF ou CNPJ ou Other",
  "email": "email"
}' |  \
  http DELETE {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method DELETE \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "document": "number",\n  "documentType": "CPF ou CNPJ ou Other",\n  "email": "email"\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId

import Foundation

let headers = [
  "accept": "",
  "content-type": "application/json"
]
let parameters = [
  "document": "number",
  "documentType": "CPF ou CNPJ ou Other",
  "email": "email"
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId" {:headers {:accept ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:expirationDate "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)"
                                                                                                                                 :installments "integer (optional default is 1)"
                                                                                                                                 :settle false
                                                                                                                                 :value "decimal (required)"}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"

	payload := strings.NewReader("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}")

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

	req.Header.Add("accept", "")
	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/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId HTTP/1.1
Accept: 
Content-Type: application/json
Host: example.com
Content-Length: 196

{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")
  .setHeader("accept", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"))
    .header("accept", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\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  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")
  .header("accept", "")
  .header("content-type", "application/json")
  .body("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}")
  .asString();

const data = JSON.stringify({
  expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  installments: 'integer (optional default is 1)',
  settle: false,
  value: 'decimal (required)'
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {
    expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
    installments: 'integer (optional default is 1)',
    settle: false,
    value: 'decimal (required)'
  }
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"expirationDate":"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)","installments":"integer (optional default is 1)","settle":false,"value":"decimal (required)"}'
};

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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",\n  "installments": "integer (optional default is 1)",\n  "settle": false,\n  "value": "decimal (required)"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")
  .put(body)
  .addHeader("accept", "")
  .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/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  headers: {
    accept: '',
    '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({
  expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  installments: 'integer (optional default is 1)',
  settle: false,
  value: 'decimal (required)'
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  headers: {accept: '', 'content-type': 'application/json'},
  body: {
    expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
    installments: 'integer (optional default is 1)',
    settle: false,
    value: 'decimal (required)'
  },
  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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId');

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

req.type('json');
req.send({
  expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  installments: 'integer (optional default is 1)',
  settle: false,
  value: 'decimal (required)'
});

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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {
    expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
    installments: 'integer (optional default is 1)',
    settle: false,
    value: 'decimal (required)'
  }
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"expirationDate":"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)","installments":"integer (optional default is 1)","settle":false,"value":"decimal (required)"}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"expirationDate": @"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
                              @"installments": @"integer (optional default is 1)",
                              @"settle": @NO,
                              @"value": @"decimal (required)" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId",
  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([
    'expirationDate' => 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
    'installments' => 'integer (optional default is 1)',
    'settle' => null,
    'value' => 'decimal (required)'
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId', [
  'body' => '{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'expirationDate' => 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  'installments' => 'integer (optional default is 1)',
  'settle' => null,
  'value' => 'decimal (required)'
]));

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

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

append(json_encode([
  'expirationDate' => 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  'installments' => 'integer (optional default is 1)',
  'settle' => null,
  'value' => 'decimal (required)'
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}'

import http.client

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

payload = "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}"

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

conn.request("PUT", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"

payload = {
    "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
    "installments": "integer (optional default is 1)",
    "settle": False,
    "value": "decimal (required)"
}
headers = {
    "accept": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId"

payload <- "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")

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

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\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/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId";

    let payload = json!({
        "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
        "installments": "integer (optional default is 1)",
        "settle": false,
        "value": "decimal (required)"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".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 '{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",\n  "installments": "integer (optional default is 1)",\n  "settle": false,\n  "value": "decimal (required)"\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId

import Foundation

let headers = [
  "accept": "",
  "content-type": "application/json"
]
let parameters = [
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId")! 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}}/api/creditcontrol/accounts/:creditAccountId/transaction");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction" {:headers {:accept ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:expirationDate "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)"
                                                                                                                  :installments "integer (optional default is 1)"
                                                                                                                  :settle false
                                                                                                                  :value "decimal (required)"}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\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}}/api/creditcontrol/accounts/:creditAccountId/transaction"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\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}}/api/creditcontrol/accounts/:creditAccountId/transaction");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction"

	payload := strings.NewReader("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}")

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

	req.Header.Add("accept", "")
	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/api/creditcontrol/accounts/:creditAccountId/transaction HTTP/1.1
Accept: 
Content-Type: application/json
Host: example.com
Content-Length: 196

{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction")
  .setHeader("accept", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction"))
    .header("accept", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\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  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction")
  .header("accept", "")
  .header("content-type", "application/json")
  .body("{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}")
  .asString();

const data = JSON.stringify({
  expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  installments: 'integer (optional default is 1)',
  settle: false,
  value: 'decimal (required)'
});

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

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

xhr.open('POST', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {
    expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
    installments: 'integer (optional default is 1)',
    settle: false,
    value: 'decimal (required)'
  }
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"expirationDate":"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)","installments":"integer (optional default is 1)","settle":false,"value":"decimal (required)"}'
};

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}}/api/creditcontrol/accounts/:creditAccountId/transaction',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",\n  "installments": "integer (optional default is 1)",\n  "settle": false,\n  "value": "decimal (required)"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction")
  .post(body)
  .addHeader("accept", "")
  .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/api/creditcontrol/accounts/:creditAccountId/transaction',
  headers: {
    accept: '',
    '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({
  expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  installments: 'integer (optional default is 1)',
  settle: false,
  value: 'decimal (required)'
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction',
  headers: {accept: '', 'content-type': 'application/json'},
  body: {
    expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
    installments: 'integer (optional default is 1)',
    settle: false,
    value: 'decimal (required)'
  },
  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}}/api/creditcontrol/accounts/:creditAccountId/transaction');

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

req.type('json');
req.send({
  expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  installments: 'integer (optional default is 1)',
  settle: false,
  value: 'decimal (required)'
});

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}}/api/creditcontrol/accounts/:creditAccountId/transaction',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {
    expirationDate: 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
    installments: 'integer (optional default is 1)',
    settle: false,
    value: 'decimal (required)'
  }
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"expirationDate":"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)","installments":"integer (optional default is 1)","settle":false,"value":"decimal (required)"}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"expirationDate": @"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
                              @"installments": @"integer (optional default is 1)",
                              @"settle": @NO,
                              @"value": @"decimal (required)" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/transaction" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction",
  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([
    'expirationDate' => 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
    'installments' => 'integer (optional default is 1)',
    'settle' => null,
    'value' => 'decimal (required)'
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction', [
  'body' => '{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'expirationDate' => 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  'installments' => 'integer (optional default is 1)',
  'settle' => null,
  'value' => 'decimal (required)'
]));

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

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

append(json_encode([
  'expirationDate' => 'date in ISO8601 (UTC) dateformat (optional default is 1(one) day)',
  'installments' => 'integer (optional default is 1)',
  'settle' => null,
  'value' => 'decimal (required)'
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}'

import http.client

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

payload = "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}"

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

conn.request("POST", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/transaction", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction"

payload = {
    "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
    "installments": "integer (optional default is 1)",
    "settle": False,
    "value": "decimal (required)"
}
headers = {
    "accept": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction"

payload <- "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction")

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

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\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/api/creditcontrol/accounts/:creditAccountId/transaction') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"expirationDate\": \"date in ISO8601 (UTC) dateformat (optional default is 1(one) day)\",\n  \"installments\": \"integer (optional default is 1)\",\n  \"settle\": false,\n  \"value\": \"decimal (required)\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
        "installments": "integer (optional default is 1)",
        "settle": false,
        "value": "decimal (required)"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".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 '{
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
}' |  \
  http POST {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",\n  "installments": "integer (optional default is 1)",\n  "settle": false,\n  "value": "decimal (required)"\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transaction

import Foundation

let headers = [
  "accept": "",
  "content-type": "application/json"
]
let parameters = [
  "expirationDate": "date in ISO8601 (UTC) dateformat (optional default is 1(one) day)",
  "installments": "integer (optional default is 1)",
  "settle": false,
  "value": "decimal (required)"
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"value\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement" {:headers {:accept ""}
                                                                                                                              :content-type :json
                                                                                                                              :form-params {:value ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"value\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"value\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement"

	payload := strings.NewReader("{\n  \"value\": \"\"\n}")

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

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

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

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

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

}

PUT /baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 17

{
  "value": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement"))
    .header("accept", "")
    .header("content-type", "")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"value\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"value\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement',
  headers: {accept: '', 'content-type': ''},
  data: {value: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement';
const options = {method: 'PUT', headers: {accept: '', 'content-type': ''}, body: '{"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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "value": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement',
  headers: {
    accept: '',
    'content-type': ''
  }
};

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({value: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement',
  headers: {accept: '', 'content-type': ''},
  body: {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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement',
  headers: {accept: '', 'content-type': ''},
  data: {value: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement';
const options = {method: 'PUT', headers: {accept: '', 'content-type': ''}, body: '{"value":""}'};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"value": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"value\": \"\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement",
  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([
    'value' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement', [
  'body' => '{
  "value": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

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

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

append(json_encode([
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement' -Method PUT -Headers $headers -ContentType '' -Body '{
  "value": ""
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement' -Method PUT -Headers $headers -ContentType '' -Body '{
  "value": ""
}'

import http.client

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

payload = "{\n  \"value\": \"\"\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("PUT", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement"

payload = { "value": "" }
headers = {
    "accept": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement"

payload <- "{\n  \"value\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement")

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

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"value\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"value\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement";

    let payload = json!({"value": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".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 '{
  "value": ""
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement \
  accept:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "value": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = ["value": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/settlement")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"value\": \"-number\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId" {:headers {:accept ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:value "-number"}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"value\": \"-number\"\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}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"value\": \"-number\"\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}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"value\": \"-number\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId"

	payload := strings.NewReader("{\n  \"value\": \"-number\"\n}")

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

	req.Header.Add("accept", "")
	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/api/creditcontrol/accounts/:creditAccountId/statements/:statementId HTTP/1.1
Accept: 
Content-Type: application/json
Host: example.com
Content-Length: 24

{
  "value": "-number"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId")
  .setHeader("accept", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"value\": \"-number\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId"))
    .header("accept", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"value\": \"-number\"\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  \"value\": \"-number\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId")
  .header("accept", "")
  .header("content-type", "application/json")
  .body("{\n  \"value\": \"-number\"\n}")
  .asString();

const data = JSON.stringify({
  value: '-number'
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {value: '-number'}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"value":"-number"}'
};

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}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "value": "-number"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"value\": \"-number\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId")
  .put(body)
  .addHeader("accept", "")
  .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/api/creditcontrol/accounts/:creditAccountId/statements/:statementId',
  headers: {
    accept: '',
    '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({value: '-number'}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId',
  headers: {accept: '', 'content-type': 'application/json'},
  body: {value: '-number'},
  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}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId');

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

req.type('json');
req.send({
  value: '-number'
});

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}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {value: '-number'}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"value":"-number"}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"value": @"-number" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"value\": \"-number\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId",
  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([
    'value' => '-number'
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId', [
  'body' => '{
  "value": "-number"
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'value' => '-number'
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "value": "-number"
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "value": "-number"
}'

import http.client

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

payload = "{\n  \"value\": \"-number\"\n}"

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

conn.request("PUT", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/statements/:statementId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId"

payload = { "value": "-number" }
headers = {
    "accept": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId"

payload <- "{\n  \"value\": \"-number\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId")

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

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"value\": \"-number\"\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/api/creditcontrol/accounts/:creditAccountId/statements/:statementId') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"value\": \"-number\"\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}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId";

    let payload = json!({"value": "-number"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".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 '{
  "value": "-number"
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "value": "-number"\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId

import Foundation

let headers = [
  "accept": "",
  "content-type": "application/json"
]
let parameters = ["value": "-number"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/statements/:statementId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId" {:headers {:content-type ""
                                                                                                                      :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

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

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

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

}

DELETE /baseUrl/api/creditcontrol/accounts/:creditAccountId/holders/:holderId HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId")
  .delete(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId';
const options = {method: 'DELETE', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId',
  method: 'DELETE',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId")
  .delete(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/holders/:holderId',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId',
  headers: {'content-type': '', accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId');

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId',
  headers: {'content-type': '', accept: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId';
const options = {method: 'DELETE', headers: {'content-type': '', accept: ''}};

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

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("DELETE", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/holders/:holderId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId"

headers = {
    "content-type": "",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId")

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

request = Net::HTTP::Delete.new(url)
request["content-type"] = ''
request["accept"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/api/creditcontrol/accounts/:creditAccountId/holders/:holderId') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId \
  accept:'' \
  content-type:''

wget --quiet \
  --method DELETE \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/holders/:holderId")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/creditcontrol/accounts" {:headers {:accept ""}
                                                                       :content-type :json
                                                                       :form-params {:creditLimit ""
                                                                                     :description ""
                                                                                     :document ""
                                                                                     :documentType ""
                                                                                     :email ""
                                                                                     :tolerance ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\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}}/api/creditcontrol/accounts"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\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}}/api/creditcontrol/accounts");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}")

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

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/api/creditcontrol/accounts HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 118

{
  "creditLimit": "",
  "description": "",
  "document": "",
  "documentType": "",
  "email": "",
  "tolerance": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/creditcontrol/accounts")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts"))
    .header("accept", "")
    .header("content-type", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\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  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/creditcontrol/accounts")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  creditLimit: '',
  description: '',
  document: '',
  documentType: '',
  email: '',
  tolerance: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/api/creditcontrol/accounts');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts',
  headers: {accept: '', 'content-type': ''},
  data: {
    creditLimit: '',
    description: '',
    document: '',
    documentType: '',
    email: '',
    tolerance: ''
  }
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"creditLimit":"","description":"","document":"","documentType":"","email":"","tolerance":""}'
};

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}}/api/creditcontrol/accounts',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "creditLimit": "",\n  "description": "",\n  "document": "",\n  "documentType": "",\n  "email": "",\n  "tolerance": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts',
  headers: {
    accept: '',
    'content-type': ''
  }
};

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({
  creditLimit: '',
  description: '',
  document: '',
  documentType: '',
  email: '',
  tolerance: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts',
  headers: {accept: '', 'content-type': ''},
  body: {
    creditLimit: '',
    description: '',
    document: '',
    documentType: '',
    email: '',
    tolerance: ''
  },
  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}}/api/creditcontrol/accounts');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  creditLimit: '',
  description: '',
  document: '',
  documentType: '',
  email: '',
  tolerance: ''
});

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}}/api/creditcontrol/accounts',
  headers: {accept: '', 'content-type': ''},
  data: {
    creditLimit: '',
    description: '',
    document: '',
    documentType: '',
    email: '',
    tolerance: ''
  }
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"creditLimit":"","description":"","document":"","documentType":"","email":"","tolerance":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"creditLimit": @"",
                              @"description": @"",
                              @"document": @"",
                              @"documentType": @"",
                              @"email": @"",
                              @"tolerance": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts"]
                                                       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}}/api/creditcontrol/accounts" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts",
  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([
    'creditLimit' => '',
    'description' => '',
    'document' => '',
    'documentType' => '',
    'email' => '',
    'tolerance' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/creditcontrol/accounts', [
  'body' => '{
  "creditLimit": "",
  "description": "",
  "document": "",
  "documentType": "",
  "email": "",
  "tolerance": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'creditLimit' => '',
  'description' => '',
  'document' => '',
  'documentType' => '',
  'email' => '',
  'tolerance' => ''
]));

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

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

append(json_encode([
  'creditLimit' => '',
  'description' => '',
  'document' => '',
  'documentType' => '',
  'email' => '',
  'tolerance' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts' -Method POST -Headers $headers -ContentType '' -Body '{
  "creditLimit": "",
  "description": "",
  "document": "",
  "documentType": "",
  "email": "",
  "tolerance": ""
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts' -Method POST -Headers $headers -ContentType '' -Body '{
  "creditLimit": "",
  "description": "",
  "document": "",
  "documentType": "",
  "email": "",
  "tolerance": ""
}'

import http.client

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

payload = "{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/api/creditcontrol/accounts", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts"

payload = {
    "creditLimit": "",
    "description": "",
    "document": "",
    "documentType": "",
    "email": "",
    "tolerance": ""
}
headers = {
    "accept": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/api/creditcontrol/accounts') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"creditLimit\": \"\",\n  \"description\": \"\",\n  \"document\": \"\",\n  \"documentType\": \"\",\n  \"email\": \"\",\n  \"tolerance\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "creditLimit": "",
        "description": "",
        "document": "",
        "documentType": "",
        "email": "",
        "tolerance": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".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 '{
  "creditLimit": "",
  "description": "",
  "document": "",
  "documentType": "",
  "email": "",
  "tolerance": ""
}' |  \
  http POST {{baseUrl}}/api/creditcontrol/accounts \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "creditLimit": "",\n  "description": "",\n  "document": "",\n  "documentType": "",\n  "email": "",\n  "tolerance": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = [
  "creditLimit": "",
  "description": "",
  "document": "",
  "documentType": "",
  "email": "",
  "tolerance": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/creditcontrol/accounts/:accountId" {:headers {:accept ""}
                                                                                 :content-type :json
                                                                                 :form-params {:creditLimit 0
                                                                                               :document ""
                                                                                               :email ""
                                                                                               :id ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:accountId"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\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}}/api/creditcontrol/accounts/:accountId"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:accountId");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}")

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

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

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

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

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

}

PUT /baseUrl/api/creditcontrol/accounts/:accountId HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 67

{
  "creditLimit": 0,
  "document": "",
  "email": "",
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/accounts/:accountId")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:accountId"))
    .header("accept", "")
    .header("content-type", "")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:accountId")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/accounts/:accountId")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  creditLimit: 0,
  document: '',
  email: '',
  id: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:accountId');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:accountId',
  headers: {accept: '', 'content-type': ''},
  data: {creditLimit: 0, document: '', email: '', id: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:accountId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': ''},
  body: '{"creditLimit":0,"document":"","email":"","id":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/creditcontrol/accounts/:accountId',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "creditLimit": 0,\n  "document": "",\n  "email": "",\n  "id": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:accountId")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:accountId',
  headers: {
    accept: '',
    'content-type': ''
  }
};

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({creditLimit: 0, document: '', email: '', id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:accountId',
  headers: {accept: '', 'content-type': ''},
  body: {creditLimit: 0, document: '', email: '', id: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  creditLimit: 0,
  document: '',
  email: '',
  id: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:accountId',
  headers: {accept: '', 'content-type': ''},
  data: {creditLimit: 0, document: '', email: '', id: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:accountId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': ''},
  body: '{"creditLimit":0,"document":"","email":"","id":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"creditLimit": @0,
                              @"document": @"",
                              @"email": @"",
                              @"id": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:accountId"]
                                                       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}}/api/creditcontrol/accounts/:accountId" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:accountId",
  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([
    'creditLimit' => 0,
    'document' => '',
    'email' => '',
    'id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:accountId', [
  'body' => '{
  "creditLimit": 0,
  "document": "",
  "email": "",
  "id": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'creditLimit' => 0,
  'document' => '',
  'email' => '',
  'id' => ''
]));

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

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

append(json_encode([
  'creditLimit' => 0,
  'document' => '',
  'email' => '',
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:accountId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:accountId' -Method PUT -Headers $headers -ContentType '' -Body '{
  "creditLimit": 0,
  "document": "",
  "email": "",
  "id": ""
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:accountId' -Method PUT -Headers $headers -ContentType '' -Body '{
  "creditLimit": 0,
  "document": "",
  "email": "",
  "id": ""
}'

import http.client

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

payload = "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("PUT", "/baseUrl/api/creditcontrol/accounts/:accountId", payload, headers)

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

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

import requests

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

payload = {
    "creditLimit": 0,
    "document": "",
    "email": "",
    "id": ""
}
headers = {
    "accept": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/api/creditcontrol/accounts/:accountId') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"creditLimit\": 0,\n  \"document\": \"\",\n  \"email\": \"\",\n  \"id\": \"\"\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}}/api/creditcontrol/accounts/:accountId";

    let payload = json!({
        "creditLimit": 0,
        "document": "",
        "email": "",
        "id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".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 '{
  "creditLimit": 0,
  "document": "",
  "email": "",
  "id": ""
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/accounts/:accountId \
  accept:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "creditLimit": 0,\n  "document": "",\n  "email": "",\n  "id": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:accountId

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = [
  "creditLimit": 0,
  "document": "",
  "email": "",
  "id": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:accountId")! 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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"value\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds" {:headers {:accept ""}
                                                                                                                            :content-type :json
                                                                                                                            :form-params {:value ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"value\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"value\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds"

	payload := strings.NewReader("{\n  \"value\": \"\"\n}")

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

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 17

{
  "value": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds"))
    .header("accept", "")
    .header("content-type", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"value\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"value\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds',
  headers: {accept: '', 'content-type': ''},
  data: {value: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "value": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds',
  headers: {
    accept: '',
    'content-type': ''
  }
};

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({value: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds',
  headers: {accept: '', 'content-type': ''},
  body: {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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds',
  headers: {accept: '', 'content-type': ''},
  data: {value: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"value":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"value": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"value\": \"\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds",
  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([
    'value' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds', [
  'body' => '{
  "value": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

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

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

append(json_encode([
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds' -Method POST -Headers $headers -ContentType '' -Body '{
  "value": ""
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds' -Method POST -Headers $headers -ContentType '' -Body '{
  "value": ""
}'

import http.client

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

payload = "{\n  \"value\": \"\"\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds"

payload = { "value": "" }
headers = {
    "accept": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds"

payload <- "{\n  \"value\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds")

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

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"value\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"value\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds";

    let payload = json!({"value": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".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 '{
  "value": ""
}' |  \
  http POST {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "value": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = ["value": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/transactions/:transactionId/refunds")! 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}}/api/creditcontrol/accounts/:creditAccountId");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId" {:headers {:content-type ""
                                                                                                 :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

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

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

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

}

GET /baseUrl/api/creditcontrol/accounts/:creditAccountId HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/accounts/:creditAccountId")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/accounts/:creditAccountId');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/accounts/:creditAccountId',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/accounts/:creditAccountId',
  headers: {'content-type': '', accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/accounts/:creditAccountId',
  headers: {'content-type': '', accept: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId' -Method GET -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/creditcontrol/accounts/:creditAccountId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"

headers = {
    "content-type": "",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")

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

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/api/creditcontrol/accounts/:creditAccountId') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/accounts/:creditAccountId \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/creditcontrol/accounts" {:headers {:content-type ""
                                                                                :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

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

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

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

}

GET /baseUrl/api/creditcontrol/accounts HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/accounts")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/creditcontrol/accounts")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/accounts');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/creditcontrol/accounts',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/accounts',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/accounts',
  headers: {'content-type': '', accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/accounts',
  headers: {'content-type': '', accept: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/creditcontrol/accounts" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/creditcontrol/accounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/creditcontrol/accounts', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts' -Method GET -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accept': ""
}

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

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts"

headers = {
    "content-type": "",
    "accept": ""
}

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

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/api/creditcontrol/accounts') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/accounts \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"email\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId" {:headers {:accept ""}
                                                                                       :content-type :json
                                                                                       :form-params {:description ""
                                                                                                     :email ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"description\": \"\",\n  \"email\": \"\"\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}}/api/creditcontrol/accounts/:creditAccountId"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"description\": \"\",\n  \"email\": \"\"\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}}/api/creditcontrol/accounts/:creditAccountId");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"description\": \"\",\n  \"email\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"email\": \"\"\n}")

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

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

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

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

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

}

PUT /baseUrl/api/creditcontrol/accounts/:creditAccountId HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 38

{
  "description": "",
  "email": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"description\": \"\",\n  \"email\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"))
    .header("accept", "")
    .header("content-type", "")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"email\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"email\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"description\": \"\",\n  \"email\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  email: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId',
  headers: {accept: '', 'content-type': ''},
  data: {description: '', email: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': ''},
  body: '{"description":"","email":""}'
};

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}}/api/creditcontrol/accounts/:creditAccountId',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "description": "",\n  "email": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"email\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId',
  headers: {
    accept: '',
    'content-type': ''
  }
};

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

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

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

req.write(JSON.stringify({description: '', email: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId',
  headers: {accept: '', 'content-type': ''},
  body: {description: '', email: ''},
  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}}/api/creditcontrol/accounts/:creditAccountId');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  description: '',
  email: ''
});

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}}/api/creditcontrol/accounts/:creditAccountId',
  headers: {accept: '', 'content-type': ''},
  data: {description: '', email: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': ''},
  body: '{"description":"","email":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"description": @"",
                              @"email": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"email\": \"\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId",
  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([
    'description' => '',
    'email' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId', [
  'body' => '{
  "description": "",
  "email": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

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

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

append(json_encode([
  'description' => '',
  'email' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId' -Method PUT -Headers $headers -ContentType '' -Body '{
  "description": "",
  "email": ""
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId' -Method PUT -Headers $headers -ContentType '' -Body '{
  "description": "",
  "email": ""
}'

import http.client

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

payload = "{\n  \"description\": \"\",\n  \"email\": \"\"\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("PUT", "/baseUrl/api/creditcontrol/accounts/:creditAccountId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"

payload = {
    "description": "",
    "email": ""
}
headers = {
    "accept": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId"

payload <- "{\n  \"description\": \"\",\n  \"email\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId")

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

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"description\": \"\",\n  \"email\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/api/creditcontrol/accounts/:creditAccountId') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"description\": \"\",\n  \"email\": \"\"\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}}/api/creditcontrol/accounts/:creditAccountId";

    let payload = json!({
        "description": "",
        "email": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".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 '{
  "description": "",
  "email": ""
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId \
  accept:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "description": "",\n  "email": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = [
  "description": "",
  "email": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId" {:headers {:content-type ""
                                                                                                                        :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

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

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

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

}

DELETE /baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .delete(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId';
const options = {method: 'DELETE', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  method: 'DELETE',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .delete(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {'content-type': '', accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {'content-type': '', accept: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId';
const options = {method: 'DELETE', headers: {'content-type': '', accept: ''}};

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

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("DELETE", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"

headers = {
    "content-type": "",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")

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

request = Net::HTTP::Delete.new(url)
request["content-type"] = ''
request["accept"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId \
  accept:'' \
  content-type:''

wget --quiet \
  --method DELETE \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId" {:headers {:accept ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:observation "string (optional)"
                                                                                                                         :paymentLink "string (URL) (optional)"
                                                                                                                         :status "string"}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"

	payload := strings.NewReader("{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}")

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

	req.Header.Add("accept", "")
	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/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId HTTP/1.1
Accept: 
Content-Type: application/json
Host: example.com
Content-Length: 106

{
  "observation": "string (optional)",
  "paymentLink": "string (URL) (optional)",
  "status": "string"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .setHeader("accept", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"))
    .header("accept", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\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  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .header("accept", "")
  .header("content-type", "application/json")
  .body("{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}")
  .asString();

const data = JSON.stringify({
  observation: 'string (optional)',
  paymentLink: 'string (URL) (optional)',
  status: 'string'
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {
    observation: 'string (optional)',
    paymentLink: 'string (URL) (optional)',
    status: 'string'
  }
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"observation":"string (optional)","paymentLink":"string (URL) (optional)","status":"string"}'
};

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "observation": "string (optional)",\n  "paymentLink": "string (URL) (optional)",\n  "status": "string"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .put(body)
  .addHeader("accept", "")
  .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/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {
    accept: '',
    '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({
  observation: 'string (optional)',
  paymentLink: 'string (URL) (optional)',
  status: 'string'
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {accept: '', 'content-type': 'application/json'},
  body: {
    observation: 'string (optional)',
    paymentLink: 'string (URL) (optional)',
    status: 'string'
  },
  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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');

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

req.type('json');
req.send({
  observation: 'string (optional)',
  paymentLink: 'string (URL) (optional)',
  status: 'string'
});

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {
    observation: 'string (optional)',
    paymentLink: 'string (URL) (optional)',
    status: 'string'
  }
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"observation":"string (optional)","paymentLink":"string (URL) (optional)","status":"string"}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"observation": @"string (optional)",
                              @"paymentLink": @"string (URL) (optional)",
                              @"status": @"string" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId",
  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([
    'observation' => 'string (optional)',
    'paymentLink' => 'string (URL) (optional)',
    'status' => 'string'
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId', [
  'body' => '{
  "observation": "string (optional)",
  "paymentLink": "string (URL) (optional)",
  "status": "string"
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'observation' => 'string (optional)',
  'paymentLink' => 'string (URL) (optional)',
  'status' => 'string'
]));

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

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

append(json_encode([
  'observation' => 'string (optional)',
  'paymentLink' => 'string (URL) (optional)',
  'status' => 'string'
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "observation": "string (optional)",
  "paymentLink": "string (URL) (optional)",
  "status": "string"
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "observation": "string (optional)",
  "paymentLink": "string (URL) (optional)",
  "status": "string"
}'

import http.client

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

payload = "{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}"

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

conn.request("PUT", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"

payload = {
    "observation": "string (optional)",
    "paymentLink": "string (URL) (optional)",
    "status": "string"
}
headers = {
    "accept": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"

payload <- "{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")

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

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\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/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"observation\": \"string (optional)\",\n  \"paymentLink\": \"string (URL) (optional)\",\n  \"status\": \"string\"\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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId";

    let payload = json!({
        "observation": "string (optional)",
        "paymentLink": "string (URL) (optional)",
        "status": "string"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".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 '{
  "observation": "string (optional)",
  "paymentLink": "string (URL) (optional)",
  "status": "string"
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "observation": "string (optional)",\n  "paymentLink": "string (URL) (optional)",\n  "status": "string"\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId

import Foundation

let headers = [
  "accept": "",
  "content-type": "application/json"
]
let parameters = [
  "observation": "string (optional)",
  "paymentLink": "string (URL) (optional)",
  "status": "string"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")! 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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"value\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments" {:headers {:accept ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:value ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"value\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"value\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments"

	payload := strings.NewReader("{\n  \"value\": \"\"\n}")

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

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 17

{
  "value": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments"))
    .header("accept", "")
    .header("content-type", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"value\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"value\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments',
  headers: {accept: '', 'content-type': ''},
  data: {value: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "value": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments',
  headers: {
    accept: '',
    'content-type': ''
  }
};

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({value: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments',
  headers: {accept: '', 'content-type': ''},
  body: {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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments',
  headers: {accept: '', 'content-type': ''},
  data: {value: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"value":""}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"value": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"value\": \"\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments",
  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([
    'value' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments', [
  'body' => '{
  "value": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

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

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

append(json_encode([
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments' -Method POST -Headers $headers -ContentType '' -Body '{
  "value": ""
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments' -Method POST -Headers $headers -ContentType '' -Body '{
  "value": ""
}'

import http.client

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

payload = "{\n  \"value\": \"\"\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments"

payload = { "value": "" }
headers = {
    "accept": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments"

payload <- "{\n  \"value\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments")

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

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"value\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"value\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments";

    let payload = json!({"value": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".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 '{
  "value": ""
}' |  \
  http POST {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "value": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = ["value": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/payments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"dueDays\": \"number (integer)\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement" {:headers {:accept ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:dueDays "number (integer)"}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"dueDays\": \"number (integer)\"\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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"dueDays\": \"number (integer)\"\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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"dueDays\": \"number (integer)\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement"

	payload := strings.NewReader("{\n  \"dueDays\": \"number (integer)\"\n}")

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

	req.Header.Add("accept", "")
	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/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement HTTP/1.1
Accept: 
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "dueDays": "number (integer)"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement")
  .setHeader("accept", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"dueDays\": \"number (integer)\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement"))
    .header("accept", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"dueDays\": \"number (integer)\"\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  \"dueDays\": \"number (integer)\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement")
  .header("accept", "")
  .header("content-type", "application/json")
  .body("{\n  \"dueDays\": \"number (integer)\"\n}")
  .asString();

const data = JSON.stringify({
  dueDays: 'number (integer)'
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {dueDays: 'number (integer)'}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"dueDays":"number (integer)"}'
};

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "dueDays": "number (integer)"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"dueDays\": \"number (integer)\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement")
  .put(body)
  .addHeader("accept", "")
  .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/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement',
  headers: {
    accept: '',
    '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({dueDays: 'number (integer)'}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement',
  headers: {accept: '', 'content-type': 'application/json'},
  body: {dueDays: 'number (integer)'},
  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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement');

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

req.type('json');
req.send({
  dueDays: 'number (integer)'
});

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {dueDays: 'number (integer)'}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"dueDays":"number (integer)"}'
};

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

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dueDays": @"number (integer)" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"dueDays\": \"number (integer)\"\n}" in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement",
  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([
    'dueDays' => 'number (integer)'
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement', [
  'body' => '{
  "dueDays": "number (integer)"
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'dueDays' => 'number (integer)'
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "dueDays": "number (integer)"
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "dueDays": "number (integer)"
}'

import http.client

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

payload = "{\n  \"dueDays\": \"number (integer)\"\n}"

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

conn.request("PUT", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement"

payload = { "dueDays": "number (integer)" }
headers = {
    "accept": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement"

payload <- "{\n  \"dueDays\": \"number (integer)\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement")

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

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"dueDays\": \"number (integer)\"\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/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"dueDays\": \"number (integer)\"\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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement";

    let payload = json!({"dueDays": "number (integer)"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".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 '{
  "dueDays": "number (integer)"
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "dueDays": "number (integer)"\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement

import Foundation

let headers = [
  "accept": "",
  "content-type": "application/json"
]
let parameters = ["dueDays": "number (integer)"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId/postponement")! 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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId" {:headers {:content-type ""
                                                                                                                     :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

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

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

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

}

GET /baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {'content-type': '', accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId',
  headers: {'content-type': '', accept: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId' -Method GET -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"

headers = {
    "content-type": "",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")

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

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices/:invoiceId")! 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}}/api/creditcontrol/accounts/:creditAccountId/invoices");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices" {:headers {:content-type ""
                                                                                                          :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

var client = new RestClient("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

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

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

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

}

GET /baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/accounts/:creditAccountId/invoices")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/accounts/:creditAccountId/invoices');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/accounts/:creditAccountId/invoices',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/accounts/:creditAccountId/invoices',
  headers: {'content-type': '', accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices');

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/accounts/:creditAccountId/invoices',
  headers: {'content-type': '', accept: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices"]
                                                       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}}/api/creditcontrol/accounts/:creditAccountId/invoices" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices' -Method GET -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices"

headers = {
    "content-type": "",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices")

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

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/api/creditcontrol/accounts/:creditAccountId/invoices') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/accounts/:creditAccountId/invoices \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/accounts/:creditAccountId/invoices

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/creditcontrol/invoices" {:headers {:content-type ""
                                                                                :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/invoices"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

var client = new RestClient("{{baseUrl}}/api/creditcontrol/invoices");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/creditcontrol/invoices"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

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

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

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

}

GET /baseUrl/api/creditcontrol/invoices HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/creditcontrol/invoices")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/invoices"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/invoices")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/creditcontrol/invoices")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/invoices');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/creditcontrol/invoices',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/creditcontrol/invoices';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/invoices',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/invoices")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/invoices',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/invoices',
  headers: {'content-type': '', accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/creditcontrol/invoices');

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/invoices',
  headers: {'content-type': '', accept: ''}
};

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

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

const url = '{{baseUrl}}/api/creditcontrol/invoices';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/invoices"]
                                                       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}}/api/creditcontrol/invoices" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/creditcontrol/invoices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/creditcontrol/invoices', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/invoices');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/creditcontrol/invoices');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/invoices' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/invoices' -Method GET -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/creditcontrol/invoices", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/creditcontrol/invoices"

headers = {
    "content-type": "",
    "accept": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/invoices"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/invoices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/creditcontrol/invoices') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/creditcontrol/invoices";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/invoices \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/invoices

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/invoices")! 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}}/api/creditcontrol/storeconfig");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/creditcontrol/storeconfig" {:headers {:accept ""}
                                                                         :content-type :json
                                                                         :form-params {:automaticCheckingAccountCreationEnabled false
                                                                                       :dailyInterestRate ""
                                                                                       :defaultCreditValue ""
                                                                                       :invoicePostponementLimit ""
                                                                                       :maxPostponementDays ""
                                                                                       :maxPreAuthorizationGrowthRate ""
                                                                                       :myCreditsEnabled false
                                                                                       :notificationsSettings {:daysAfter [{:days 0
                                                                                                                            :timeOfDay ""}]
                                                                                                               :daysPrior [{:days 0
                                                                                                                            :timeOfDay ""}]}
                                                                                       :postponementEnabled false
                                                                                       :taxRate ""
                                                                                       :toleranceEnabled false}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/storeconfig"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\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}}/api/creditcontrol/storeconfig"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/storeconfig");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/creditcontrol/storeconfig"

	payload := strings.NewReader("{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/creditcontrol/storeconfig HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 521

{
  "automaticCheckingAccountCreationEnabled": false,
  "dailyInterestRate": "",
  "defaultCreditValue": "",
  "invoicePostponementLimit": "",
  "maxPostponementDays": "",
  "maxPreAuthorizationGrowthRate": "",
  "myCreditsEnabled": false,
  "notificationsSettings": {
    "daysAfter": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ],
    "daysPrior": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ]
  },
  "postponementEnabled": false,
  "taxRate": "",
  "toleranceEnabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/creditcontrol/storeconfig")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/storeconfig"))
    .header("accept", "")
    .header("content-type", "")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/storeconfig")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/creditcontrol/storeconfig")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}")
  .asString();

const data = JSON.stringify({
  automaticCheckingAccountCreationEnabled: false,
  dailyInterestRate: '',
  defaultCreditValue: '',
  invoicePostponementLimit: '',
  maxPostponementDays: '',
  maxPreAuthorizationGrowthRate: '',
  myCreditsEnabled: false,
  notificationsSettings: {
    daysAfter: [
      {
        days: 0,
        timeOfDay: ''
      }
    ],
    daysPrior: [
      {
        days: 0,
        timeOfDay: ''
      }
    ]
  },
  postponementEnabled: false,
  taxRate: '',
  toleranceEnabled: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/creditcontrol/storeconfig');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/storeconfig',
  headers: {accept: '', 'content-type': ''},
  data: {
    automaticCheckingAccountCreationEnabled: false,
    dailyInterestRate: '',
    defaultCreditValue: '',
    invoicePostponementLimit: '',
    maxPostponementDays: '',
    maxPreAuthorizationGrowthRate: '',
    myCreditsEnabled: false,
    notificationsSettings: {daysAfter: [{days: 0, timeOfDay: ''}], daysPrior: [{days: 0, timeOfDay: ''}]},
    postponementEnabled: false,
    taxRate: '',
    toleranceEnabled: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/creditcontrol/storeconfig';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': ''},
  body: '{"automaticCheckingAccountCreationEnabled":false,"dailyInterestRate":"","defaultCreditValue":"","invoicePostponementLimit":"","maxPostponementDays":"","maxPreAuthorizationGrowthRate":"","myCreditsEnabled":false,"notificationsSettings":{"daysAfter":[{"days":0,"timeOfDay":""}],"daysPrior":[{"days":0,"timeOfDay":""}]},"postponementEnabled":false,"taxRate":"","toleranceEnabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/creditcontrol/storeconfig',
  method: 'PUT',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "automaticCheckingAccountCreationEnabled": false,\n  "dailyInterestRate": "",\n  "defaultCreditValue": "",\n  "invoicePostponementLimit": "",\n  "maxPostponementDays": "",\n  "maxPreAuthorizationGrowthRate": "",\n  "myCreditsEnabled": false,\n  "notificationsSettings": {\n    "daysAfter": [\n      {\n        "days": 0,\n        "timeOfDay": ""\n      }\n    ],\n    "daysPrior": [\n      {\n        "days": 0,\n        "timeOfDay": ""\n      }\n    ]\n  },\n  "postponementEnabled": false,\n  "taxRate": "",\n  "toleranceEnabled": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/storeconfig")
  .put(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/storeconfig',
  headers: {
    accept: '',
    'content-type': ''
  }
};

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({
  automaticCheckingAccountCreationEnabled: false,
  dailyInterestRate: '',
  defaultCreditValue: '',
  invoicePostponementLimit: '',
  maxPostponementDays: '',
  maxPreAuthorizationGrowthRate: '',
  myCreditsEnabled: false,
  notificationsSettings: {daysAfter: [{days: 0, timeOfDay: ''}], daysPrior: [{days: 0, timeOfDay: ''}]},
  postponementEnabled: false,
  taxRate: '',
  toleranceEnabled: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/storeconfig',
  headers: {accept: '', 'content-type': ''},
  body: {
    automaticCheckingAccountCreationEnabled: false,
    dailyInterestRate: '',
    defaultCreditValue: '',
    invoicePostponementLimit: '',
    maxPostponementDays: '',
    maxPreAuthorizationGrowthRate: '',
    myCreditsEnabled: false,
    notificationsSettings: {daysAfter: [{days: 0, timeOfDay: ''}], daysPrior: [{days: 0, timeOfDay: ''}]},
    postponementEnabled: false,
    taxRate: '',
    toleranceEnabled: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/creditcontrol/storeconfig');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  automaticCheckingAccountCreationEnabled: false,
  dailyInterestRate: '',
  defaultCreditValue: '',
  invoicePostponementLimit: '',
  maxPostponementDays: '',
  maxPreAuthorizationGrowthRate: '',
  myCreditsEnabled: false,
  notificationsSettings: {
    daysAfter: [
      {
        days: 0,
        timeOfDay: ''
      }
    ],
    daysPrior: [
      {
        days: 0,
        timeOfDay: ''
      }
    ]
  },
  postponementEnabled: false,
  taxRate: '',
  toleranceEnabled: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/creditcontrol/storeconfig',
  headers: {accept: '', 'content-type': ''},
  data: {
    automaticCheckingAccountCreationEnabled: false,
    dailyInterestRate: '',
    defaultCreditValue: '',
    invoicePostponementLimit: '',
    maxPostponementDays: '',
    maxPreAuthorizationGrowthRate: '',
    myCreditsEnabled: false,
    notificationsSettings: {daysAfter: [{days: 0, timeOfDay: ''}], daysPrior: [{days: 0, timeOfDay: ''}]},
    postponementEnabled: false,
    taxRate: '',
    toleranceEnabled: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/creditcontrol/storeconfig';
const options = {
  method: 'PUT',
  headers: {accept: '', 'content-type': ''},
  body: '{"automaticCheckingAccountCreationEnabled":false,"dailyInterestRate":"","defaultCreditValue":"","invoicePostponementLimit":"","maxPostponementDays":"","maxPreAuthorizationGrowthRate":"","myCreditsEnabled":false,"notificationsSettings":{"daysAfter":[{"days":0,"timeOfDay":""}],"daysPrior":[{"days":0,"timeOfDay":""}]},"postponementEnabled":false,"taxRate":"","toleranceEnabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"automaticCheckingAccountCreationEnabled": @NO,
                              @"dailyInterestRate": @"",
                              @"defaultCreditValue": @"",
                              @"invoicePostponementLimit": @"",
                              @"maxPostponementDays": @"",
                              @"maxPreAuthorizationGrowthRate": @"",
                              @"myCreditsEnabled": @NO,
                              @"notificationsSettings": @{ @"daysAfter": @[ @{ @"days": @0, @"timeOfDay": @"" } ], @"daysPrior": @[ @{ @"days": @0, @"timeOfDay": @"" } ] },
                              @"postponementEnabled": @NO,
                              @"taxRate": @"",
                              @"toleranceEnabled": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/storeconfig"]
                                                       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}}/api/creditcontrol/storeconfig" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/creditcontrol/storeconfig",
  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([
    'automaticCheckingAccountCreationEnabled' => null,
    'dailyInterestRate' => '',
    'defaultCreditValue' => '',
    'invoicePostponementLimit' => '',
    'maxPostponementDays' => '',
    'maxPreAuthorizationGrowthRate' => '',
    'myCreditsEnabled' => null,
    'notificationsSettings' => [
        'daysAfter' => [
                [
                                'days' => 0,
                                'timeOfDay' => ''
                ]
        ],
        'daysPrior' => [
                [
                                'days' => 0,
                                'timeOfDay' => ''
                ]
        ]
    ],
    'postponementEnabled' => null,
    'taxRate' => '',
    'toleranceEnabled' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/creditcontrol/storeconfig', [
  'body' => '{
  "automaticCheckingAccountCreationEnabled": false,
  "dailyInterestRate": "",
  "defaultCreditValue": "",
  "invoicePostponementLimit": "",
  "maxPostponementDays": "",
  "maxPreAuthorizationGrowthRate": "",
  "myCreditsEnabled": false,
  "notificationsSettings": {
    "daysAfter": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ],
    "daysPrior": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ]
  },
  "postponementEnabled": false,
  "taxRate": "",
  "toleranceEnabled": false
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/storeconfig');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'automaticCheckingAccountCreationEnabled' => null,
  'dailyInterestRate' => '',
  'defaultCreditValue' => '',
  'invoicePostponementLimit' => '',
  'maxPostponementDays' => '',
  'maxPreAuthorizationGrowthRate' => '',
  'myCreditsEnabled' => null,
  'notificationsSettings' => [
    'daysAfter' => [
        [
                'days' => 0,
                'timeOfDay' => ''
        ]
    ],
    'daysPrior' => [
        [
                'days' => 0,
                'timeOfDay' => ''
        ]
    ]
  ],
  'postponementEnabled' => null,
  'taxRate' => '',
  'toleranceEnabled' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'automaticCheckingAccountCreationEnabled' => null,
  'dailyInterestRate' => '',
  'defaultCreditValue' => '',
  'invoicePostponementLimit' => '',
  'maxPostponementDays' => '',
  'maxPreAuthorizationGrowthRate' => '',
  'myCreditsEnabled' => null,
  'notificationsSettings' => [
    'daysAfter' => [
        [
                'days' => 0,
                'timeOfDay' => ''
        ]
    ],
    'daysPrior' => [
        [
                'days' => 0,
                'timeOfDay' => ''
        ]
    ]
  ],
  'postponementEnabled' => null,
  'taxRate' => '',
  'toleranceEnabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/creditcontrol/storeconfig');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/storeconfig' -Method PUT -Headers $headers -ContentType '' -Body '{
  "automaticCheckingAccountCreationEnabled": false,
  "dailyInterestRate": "",
  "defaultCreditValue": "",
  "invoicePostponementLimit": "",
  "maxPostponementDays": "",
  "maxPreAuthorizationGrowthRate": "",
  "myCreditsEnabled": false,
  "notificationsSettings": {
    "daysAfter": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ],
    "daysPrior": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ]
  },
  "postponementEnabled": false,
  "taxRate": "",
  "toleranceEnabled": false
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/storeconfig' -Method PUT -Headers $headers -ContentType '' -Body '{
  "automaticCheckingAccountCreationEnabled": false,
  "dailyInterestRate": "",
  "defaultCreditValue": "",
  "invoicePostponementLimit": "",
  "maxPostponementDays": "",
  "maxPreAuthorizationGrowthRate": "",
  "myCreditsEnabled": false,
  "notificationsSettings": {
    "daysAfter": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ],
    "daysPrior": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ]
  },
  "postponementEnabled": false,
  "taxRate": "",
  "toleranceEnabled": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("PUT", "/baseUrl/api/creditcontrol/storeconfig", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/creditcontrol/storeconfig"

payload = {
    "automaticCheckingAccountCreationEnabled": False,
    "dailyInterestRate": "",
    "defaultCreditValue": "",
    "invoicePostponementLimit": "",
    "maxPostponementDays": "",
    "maxPreAuthorizationGrowthRate": "",
    "myCreditsEnabled": False,
    "notificationsSettings": {
        "daysAfter": [
            {
                "days": 0,
                "timeOfDay": ""
            }
        ],
        "daysPrior": [
            {
                "days": 0,
                "timeOfDay": ""
            }
        ]
    },
    "postponementEnabled": False,
    "taxRate": "",
    "toleranceEnabled": False
}
headers = {
    "accept": "",
    "content-type": ""
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/storeconfig"

payload <- "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/storeconfig")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/api/creditcontrol/storeconfig') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"automaticCheckingAccountCreationEnabled\": false,\n  \"dailyInterestRate\": \"\",\n  \"defaultCreditValue\": \"\",\n  \"invoicePostponementLimit\": \"\",\n  \"maxPostponementDays\": \"\",\n  \"maxPreAuthorizationGrowthRate\": \"\",\n  \"myCreditsEnabled\": false,\n  \"notificationsSettings\": {\n    \"daysAfter\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ],\n    \"daysPrior\": [\n      {\n        \"days\": 0,\n        \"timeOfDay\": \"\"\n      }\n    ]\n  },\n  \"postponementEnabled\": false,\n  \"taxRate\": \"\",\n  \"toleranceEnabled\": false\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/creditcontrol/storeconfig";

    let payload = json!({
        "automaticCheckingAccountCreationEnabled": false,
        "dailyInterestRate": "",
        "defaultCreditValue": "",
        "invoicePostponementLimit": "",
        "maxPostponementDays": "",
        "maxPreAuthorizationGrowthRate": "",
        "myCreditsEnabled": false,
        "notificationsSettings": json!({
            "daysAfter": (
                json!({
                    "days": 0,
                    "timeOfDay": ""
                })
            ),
            "daysPrior": (
                json!({
                    "days": 0,
                    "timeOfDay": ""
                })
            )
        }),
        "postponementEnabled": false,
        "taxRate": "",
        "toleranceEnabled": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".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 '{
  "automaticCheckingAccountCreationEnabled": false,
  "dailyInterestRate": "",
  "defaultCreditValue": "",
  "invoicePostponementLimit": "",
  "maxPostponementDays": "",
  "maxPreAuthorizationGrowthRate": "",
  "myCreditsEnabled": false,
  "notificationsSettings": {
    "daysAfter": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ],
    "daysPrior": [
      {
        "days": 0,
        "timeOfDay": ""
      }
    ]
  },
  "postponementEnabled": false,
  "taxRate": "",
  "toleranceEnabled": false
}' |  \
  http PUT {{baseUrl}}/api/creditcontrol/storeconfig \
  accept:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "automaticCheckingAccountCreationEnabled": false,\n  "dailyInterestRate": "",\n  "defaultCreditValue": "",\n  "invoicePostponementLimit": "",\n  "maxPostponementDays": "",\n  "maxPreAuthorizationGrowthRate": "",\n  "myCreditsEnabled": false,\n  "notificationsSettings": {\n    "daysAfter": [\n      {\n        "days": 0,\n        "timeOfDay": ""\n      }\n    ],\n    "daysPrior": [\n      {\n        "days": 0,\n        "timeOfDay": ""\n      }\n    ]\n  },\n  "postponementEnabled": false,\n  "taxRate": "",\n  "toleranceEnabled": false\n}' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/storeconfig

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = [
  "automaticCheckingAccountCreationEnabled": false,
  "dailyInterestRate": "",
  "defaultCreditValue": "",
  "invoicePostponementLimit": "",
  "maxPostponementDays": "",
  "maxPreAuthorizationGrowthRate": "",
  "myCreditsEnabled": false,
  "notificationsSettings": [
    "daysAfter": [
      [
        "days": 0,
        "timeOfDay": ""
      ]
    ],
    "daysPrior": [
      [
        "days": 0,
        "timeOfDay": ""
      ]
    ]
  ],
  "postponementEnabled": false,
  "taxRate": "",
  "toleranceEnabled": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/storeconfig")! 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}}/api/creditcontrol/storeconfig");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/creditcontrol/storeconfig" {:headers {:content-type ""
                                                                                   :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/creditcontrol/storeconfig"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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}}/api/creditcontrol/storeconfig"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/creditcontrol/storeconfig");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/creditcontrol/storeconfig"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/creditcontrol/storeconfig HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/creditcontrol/storeconfig")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/creditcontrol/storeconfig"))
    .header("content-type", "")
    .header("accept", "")
    .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}}/api/creditcontrol/storeconfig")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/creditcontrol/storeconfig")
  .header("content-type", "")
  .header("accept", "")
  .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}}/api/creditcontrol/storeconfig');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/creditcontrol/storeconfig',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/creditcontrol/storeconfig';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

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}}/api/creditcontrol/storeconfig',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/creditcontrol/storeconfig")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/creditcontrol/storeconfig',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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}}/api/creditcontrol/storeconfig',
  headers: {'content-type': '', accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/creditcontrol/storeconfig');

req.headers({
  'content-type': '',
  accept: ''
});

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}}/api/creditcontrol/storeconfig',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/creditcontrol/storeconfig';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/creditcontrol/storeconfig"]
                                                       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}}/api/creditcontrol/storeconfig" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/creditcontrol/storeconfig",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/creditcontrol/storeconfig', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/creditcontrol/storeconfig');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/creditcontrol/storeconfig');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/creditcontrol/storeconfig' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/creditcontrol/storeconfig' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/creditcontrol/storeconfig", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/creditcontrol/storeconfig"

headers = {
    "content-type": "",
    "accept": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/creditcontrol/storeconfig"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/creditcontrol/storeconfig")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/creditcontrol/storeconfig') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/creditcontrol/storeconfig";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".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}}/api/creditcontrol/storeconfig \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/creditcontrol/storeconfig

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/creditcontrol/storeconfig")! 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()