Checkout API

POST Add client preferences

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData" {:headers {:content-type ""
                                                                                                                                :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData"),
    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/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData',
  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/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientPreferencesData")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

POST Add client profile

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData" {:headers {:content-type ""
                                                                                                                            :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData"),
    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/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData',
  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/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/clientProfileData")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

POST Add marketing data

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData" {:headers {:content-type ""
                                                                                                                        :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData"),
    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/checkout/pub/orderForm/:orderFormId/attachments/marketingData");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/marketingData',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData',
  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/checkout/pub/orderForm/:orderFormId/attachments/marketingData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/marketingData"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/attachments/marketingData" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/attachments/marketingData', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/attachments/marketingData' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/marketingData")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

POST Add merchant context data

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData" {:headers {:content-type ""
                                                                                                                              :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData"),
    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/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData',
  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/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/merchantContextData")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

POST Add payment data

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData" {:headers {:content-type ""
                                                                                                                      :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData"),
    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/checkout/pub/orderForm/:orderFormId/attachments/paymentData");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/paymentData',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData',
  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/checkout/pub/orderForm/:orderFormId/attachments/paymentData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/paymentData"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/attachments/paymentData" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/attachments/paymentData', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/attachments/paymentData' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/paymentData")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

POST Add shipping address and select delivery option

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData" {:headers {:content-type ""
                                                                                                                       :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData"),
    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/checkout/pub/orderForm/:orderFormId/attachments/shippingData");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/shippingData',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData',
  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/checkout/pub/orderForm/:orderFormId/attachments/shippingData';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/attachments/shippingData"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/attachments/shippingData" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/attachments/shippingData', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/attachments/shippingData' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/attachments/shippingData")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

GET Get client profile by email

{{baseUrl}}/api/checkout/pub/profiles

HEADERS

Content-Type

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/profiles?email=");

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/checkout/pub/profiles" {:headers {:content-type ""
                                                                               :accept ""}
                                                                     :query-params {:email ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/profiles?email="
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/checkout/pub/profiles?email="),
    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/checkout/pub/profiles?email=");
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/checkout/pub/profiles?email="

	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/checkout/pub/profiles?email= HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/checkout/pub/profiles?email=")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/profiles?email="))
    .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/checkout/pub/profiles?email=")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pub/profiles?email=")
  .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/checkout/pub/profiles?email=');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pub/profiles',
  params: {email: ''},
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/profiles?email=';
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/checkout/pub/profiles?email=',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/profiles?email=")
  .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/checkout/pub/profiles?email=',
  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/checkout/pub/profiles',
  qs: {email: ''},
  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/checkout/pub/profiles');

req.query({
  email: ''
});

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/checkout/pub/profiles',
  params: {email: ''},
  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/checkout/pub/profiles?email=';
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/checkout/pub/profiles?email="]
                                                       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/checkout/pub/profiles?email=" 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/checkout/pub/profiles?email=",
  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/checkout/pub/profiles?email=', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/profiles');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'email' => ''
]);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/profiles');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'email' => ''
]));

$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/checkout/pub/profiles?email=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/profiles?email=' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/api/checkout/pub/profiles?email=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/profiles"

querystring = {"email":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/profiles"

queryString <- list(email = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/profiles?email=")

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/checkout/pub/profiles') do |req|
  req.headers['accept'] = ''
  req.params['email'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("email", ""),
    ];

    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)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/checkout/pub/profiles?email=' \
  --header 'accept: ' \
  --header 'content-type: '

http GET '{{baseUrl}}/api/checkout/pub/profiles?email=' \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/api/checkout/pub/profiles?email='

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/profiles?email=")! 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()

POST Clear orderForm messages

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear" {:headers {:content-type ""
                                                                                                             :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear"),
    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/checkout/pub/orderForm/:orderFormId/messages/clear");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/messages/clear HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/messages/clear',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/messages/clear',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear',
  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/checkout/pub/orderForm/:orderFormId/messages/clear';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/messages/clear"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/messages/clear" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/messages/clear', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/messages/clear' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/messages/clear", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/messages/clear') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/messages/clear")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

GET Get orderForm configuration

{{baseUrl}}/api/checkout/pvt/configuration/orderForm

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pvt/configuration/orderForm");

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/checkout/pvt/configuration/orderForm" {:headers {:content-type ""
                                                                                              :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pvt/configuration/orderForm"
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/checkout/pvt/configuration/orderForm"),
    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/checkout/pvt/configuration/orderForm");
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/checkout/pvt/configuration/orderForm"

	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/checkout/pvt/configuration/orderForm HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/checkout/pvt/configuration/orderForm")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pvt/configuration/orderForm"))
    .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/checkout/pvt/configuration/orderForm")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pvt/configuration/orderForm")
  .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/checkout/pvt/configuration/orderForm');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/orderForm',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pvt/configuration/orderForm';
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/checkout/pvt/configuration/orderForm',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/orderForm")
  .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/checkout/pvt/configuration/orderForm',
  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/checkout/pvt/configuration/orderForm',
  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/checkout/pvt/configuration/orderForm');

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/checkout/pvt/configuration/orderForm',
  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/checkout/pvt/configuration/orderForm';
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/checkout/pvt/configuration/orderForm"]
                                                       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/checkout/pvt/configuration/orderForm" 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/checkout/pvt/configuration/orderForm",
  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/checkout/pvt/configuration/orderForm', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pvt/configuration/orderForm');
$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/checkout/pvt/configuration/orderForm');
$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/checkout/pvt/configuration/orderForm' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pvt/configuration/orderForm' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/api/checkout/pvt/configuration/orderForm", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pvt/configuration/orderForm"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pvt/configuration/orderForm"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pvt/configuration/orderForm")

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/checkout/pvt/configuration/orderForm') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pvt/configuration/orderForm";

    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);
}

curl --request GET \
  --url {{baseUrl}}/api/checkout/pvt/configuration/orderForm \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/checkout/pvt/configuration/orderForm \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pvt/configuration/orderForm

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pvt/configuration/orderForm")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "allowManualPrice": true,
  "allowMultipleDeliveries": false,
  "apps": [
    {
      "fields": [
        "name",
        "age"
      ],
      "id": "abcd",
      "major": 1
    }
  ],
  "decimalDigitsPrecision": 2,
  "maskFirstPurchaseData": null,
  "maxNumberOfWhiteLabelSellers": null,
  "minimumQuantityAccumulatedForItems": 1,
  "minimumValueAccumulated": null,
  "paymentConfiguration": {
    "allowInstallmentsMerge": null,
    "blockPaymentSession": null,
    "requiresAuthenticationForPreAuthorizedPaymentOption": false
  },
  "recaptchaValidation": "vtexCriteria",
  "taxConfiguration": null
}

GET Get window to change seller

{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller");

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/checkout/pvt/configuration/window-to-change-seller" {:headers {:content-type ""
                                                                                                            :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"
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/checkout/pvt/configuration/window-to-change-seller"),
    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/checkout/pvt/configuration/window-to-change-seller");
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/checkout/pvt/configuration/window-to-change-seller"

	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/checkout/pvt/configuration/window-to-change-seller HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"))
    .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/checkout/pvt/configuration/window-to-change-seller")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .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/checkout/pvt/configuration/window-to-change-seller');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller';
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/checkout/pvt/configuration/window-to-change-seller',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .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/checkout/pvt/configuration/window-to-change-seller',
  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/checkout/pvt/configuration/window-to-change-seller',
  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/checkout/pvt/configuration/window-to-change-seller');

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/checkout/pvt/configuration/window-to-change-seller',
  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/checkout/pvt/configuration/window-to-change-seller';
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/checkout/pvt/configuration/window-to-change-seller"]
                                                       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/checkout/pvt/configuration/window-to-change-seller" 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/checkout/pvt/configuration/window-to-change-seller",
  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/checkout/pvt/configuration/window-to-change-seller', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');
$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/checkout/pvt/configuration/window-to-change-seller');
$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/checkout/pvt/configuration/window-to-change-seller' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/api/checkout/pvt/configuration/window-to-change-seller", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")

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/checkout/pvt/configuration/window-to-change-seller') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller";

    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);
}

curl --request GET \
  --url {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")! 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()

RESPONSE HEADERS

Content-Type

text/plain

RESPONSE BODY text

POST Update orderForm configuration

{{baseUrl}}/api/checkout/pvt/configuration/orderForm

HEADERS

Content-Type

BODY json

{
  "allowManualPrice": false,
  "allowMultipleDeliveries": false,
  "apps": [
    {
      "fields": [],
      "id": "",
      "major": 0
    }
  ],
  "decimalDigitsPrecision": 0,
  "maskFirstPurchaseData": false,
  "maxNumberOfWhiteLabelSellers": 0,
  "minimumQuantityAccumulatedForItems": 0,
  "minimumValueAccumulated": 0,
  "paymentConfiguration": {
    "allowInstallmentsMerge": false,
    "requiresAuthenticationForPreAuthorizedPaymentOption": false
  },
  "paymentSystemToCheckFirstInstallment": "",
  "recaptchaValidation": "",
  "taxConfiguration": {
    "appId": "",
    "authorizationHeader": "",
    "url": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pvt/configuration/orderForm");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/checkout/pvt/configuration/orderForm" {:headers {:accept ""}
                                                                                     :content-type :json
                                                                                     :form-params {:allowManualPrice nil
                                                                                                   :allowMultipleDeliveries nil
                                                                                                   :apps nil
                                                                                                   :decimalDigitsPrecision 2
                                                                                                   :minimumQuantityAccumulatedForItems 1
                                                                                                   :minimumValueAccumulated nil
                                                                                                   :paymentConfiguration {:requiresAuthenticationForPreAuthorizedPaymentOption false}
                                                                                                   :taxConfiguration nil}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pvt/configuration/orderForm"
headers = HTTP::Headers{
  "content-type" => "application/json"
  "accept" => ""
}
reqBody = "{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\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/checkout/pvt/configuration/orderForm"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\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/checkout/pvt/configuration/orderForm");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddHeader("accept", "");
request.AddParameter("application/json", "{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pvt/configuration/orderForm"

	payload := strings.NewReader("{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}")

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

	req.Header.Add("content-type", "application/json")
	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))

}

POST /baseUrl/api/checkout/pvt/configuration/orderForm HTTP/1.1
Content-Type: application/json
Accept: 
Host: example.com
Content-Length: 316

{
  "allowManualPrice": null,
  "allowMultipleDeliveries": null,
  "apps": null,
  "decimalDigitsPrecision": 2,
  "minimumQuantityAccumulatedForItems": 1,
  "minimumValueAccumulated": null,
  "paymentConfiguration": {
    "requiresAuthenticationForPreAuthorizedPaymentOption": false
  },
  "taxConfiguration": null
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pvt/configuration/orderForm")
  .setHeader("content-type", "application/json")
  .setHeader("accept", "")
  .setBody("{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pvt/configuration/orderForm"))
    .header("content-type", "application/json")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\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  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/orderForm")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pvt/configuration/orderForm")
  .header("content-type", "application/json")
  .header("accept", "")
  .body("{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}")
  .asString();

const data = JSON.stringify({
  allowManualPrice: null,
  allowMultipleDeliveries: null,
  apps: null,
  decimalDigitsPrecision: 2,
  minimumQuantityAccumulatedForItems: 1,
  minimumValueAccumulated: null,
  paymentConfiguration: {
    requiresAuthenticationForPreAuthorizedPaymentOption: false
  },
  taxConfiguration: null
});

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

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

xhr.open('POST', '{{baseUrl}}/api/checkout/pvt/configuration/orderForm');
xhr.setRequestHeader('content-type', 'application/json');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/orderForm',
  headers: {'content-type': 'application/json', accept: ''},
  data: {
    allowManualPrice: null,
    allowMultipleDeliveries: null,
    apps: null,
    decimalDigitsPrecision: 2,
    minimumQuantityAccumulatedForItems: 1,
    minimumValueAccumulated: null,
    paymentConfiguration: {requiresAuthenticationForPreAuthorizedPaymentOption: false},
    taxConfiguration: null
  }
};

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

const url = '{{baseUrl}}/api/checkout/pvt/configuration/orderForm';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"allowManualPrice":null,"allowMultipleDeliveries":null,"apps":null,"decimalDigitsPrecision":2,"minimumQuantityAccumulatedForItems":1,"minimumValueAccumulated":null,"paymentConfiguration":{"requiresAuthenticationForPreAuthorizedPaymentOption":false},"taxConfiguration":null}'
};

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/checkout/pvt/configuration/orderForm',
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    accept: ''
  },
  processData: false,
  data: '{\n  "allowManualPrice": null,\n  "allowMultipleDeliveries": null,\n  "apps": null,\n  "decimalDigitsPrecision": 2,\n  "minimumQuantityAccumulatedForItems": 1,\n  "minimumValueAccumulated": null,\n  "paymentConfiguration": {\n    "requiresAuthenticationForPreAuthorizedPaymentOption": false\n  },\n  "taxConfiguration": null\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/orderForm")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pvt/configuration/orderForm',
  headers: {
    'content-type': 'application/json',
    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.write(JSON.stringify({
  allowManualPrice: null,
  allowMultipleDeliveries: null,
  apps: null,
  decimalDigitsPrecision: 2,
  minimumQuantityAccumulatedForItems: 1,
  minimumValueAccumulated: null,
  paymentConfiguration: {requiresAuthenticationForPreAuthorizedPaymentOption: false},
  taxConfiguration: null
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/orderForm',
  headers: {'content-type': 'application/json', accept: ''},
  body: {
    allowManualPrice: null,
    allowMultipleDeliveries: null,
    apps: null,
    decimalDigitsPrecision: 2,
    minimumQuantityAccumulatedForItems: 1,
    minimumValueAccumulated: null,
    paymentConfiguration: {requiresAuthenticationForPreAuthorizedPaymentOption: false},
    taxConfiguration: null
  },
  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/checkout/pvt/configuration/orderForm');

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

req.type('json');
req.send({
  allowManualPrice: null,
  allowMultipleDeliveries: null,
  apps: null,
  decimalDigitsPrecision: 2,
  minimumQuantityAccumulatedForItems: 1,
  minimumValueAccumulated: null,
  paymentConfiguration: {
    requiresAuthenticationForPreAuthorizedPaymentOption: false
  },
  taxConfiguration: null
});

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/checkout/pvt/configuration/orderForm',
  headers: {'content-type': 'application/json', accept: ''},
  data: {
    allowManualPrice: null,
    allowMultipleDeliveries: null,
    apps: null,
    decimalDigitsPrecision: 2,
    minimumQuantityAccumulatedForItems: 1,
    minimumValueAccumulated: null,
    paymentConfiguration: {requiresAuthenticationForPreAuthorizedPaymentOption: false},
    taxConfiguration: null
  }
};

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

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

const url = '{{baseUrl}}/api/checkout/pvt/configuration/orderForm';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"allowManualPrice":null,"allowMultipleDeliveries":null,"apps":null,"decimalDigitsPrecision":2,"minimumQuantityAccumulatedForItems":1,"minimumValueAccumulated":null,"paymentConfiguration":{"requiresAuthenticationForPreAuthorizedPaymentOption":false},"taxConfiguration":null}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json",
                           @"accept": @"" };
NSDictionary *parameters = @{ @"allowManualPrice": ,
                              @"allowMultipleDeliveries": ,
                              @"apps": ,
                              @"decimalDigitsPrecision": @2,
                              @"minimumQuantityAccumulatedForItems": @1,
                              @"minimumValueAccumulated": ,
                              @"paymentConfiguration": @{ @"requiresAuthenticationForPreAuthorizedPaymentOption": @NO },
                              @"taxConfiguration":  };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/checkout/pvt/configuration/orderForm"]
                                                       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/checkout/pvt/configuration/orderForm" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "application/json");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}" in

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

 "{{baseUrl}}/api/checkout/pvt/configuration/orderForm",
  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([
    'allowManualPrice' => null,
    'allowMultipleDeliveries' => null,
    'apps' => null,
    'decimalDigitsPrecision' => 2,
    'minimumQuantityAccumulatedForItems' => 1,
    'minimumValueAccumulated' => null,
    'paymentConfiguration' => [
        'requiresAuthenticationForPreAuthorizedPaymentOption' => null
    ],
    'taxConfiguration' => null
  ]),
  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/checkout/pvt/configuration/orderForm', [
  'body' => '{
  "allowManualPrice": null,
  "allowMultipleDeliveries": null,
  "apps": null,
  "decimalDigitsPrecision": 2,
  "minimumQuantityAccumulatedForItems": 1,
  "minimumValueAccumulated": null,
  "paymentConfiguration": {
    "requiresAuthenticationForPreAuthorizedPaymentOption": false
  },
  "taxConfiguration": null
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pvt/configuration/orderForm');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'allowManualPrice' => null,
  'allowMultipleDeliveries' => null,
  'apps' => null,
  'decimalDigitsPrecision' => 2,
  'minimumQuantityAccumulatedForItems' => 1,
  'minimumValueAccumulated' => null,
  'paymentConfiguration' => [
    'requiresAuthenticationForPreAuthorizedPaymentOption' => null
  ],
  'taxConfiguration' => null
]));

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

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

append(json_encode([
  'allowManualPrice' => null,
  'allowMultipleDeliveries' => null,
  'apps' => null,
  'decimalDigitsPrecision' => 2,
  'minimumQuantityAccumulatedForItems' => 1,
  'minimumValueAccumulated' => null,
  'paymentConfiguration' => [
    'requiresAuthenticationForPreAuthorizedPaymentOption' => null
  ],
  'taxConfiguration' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/checkout/pvt/configuration/orderForm');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/checkout/pvt/configuration/orderForm' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allowManualPrice": null,
  "allowMultipleDeliveries": null,
  "apps": null,
  "decimalDigitsPrecision": 2,
  "minimumQuantityAccumulatedForItems": 1,
  "minimumValueAccumulated": null,
  "paymentConfiguration": {
    "requiresAuthenticationForPreAuthorizedPaymentOption": false
  },
  "taxConfiguration": null
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pvt/configuration/orderForm' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allowManualPrice": null,
  "allowMultipleDeliveries": null,
  "apps": null,
  "decimalDigitsPrecision": 2,
  "minimumQuantityAccumulatedForItems": 1,
  "minimumValueAccumulated": null,
  "paymentConfiguration": {
    "requiresAuthenticationForPreAuthorizedPaymentOption": false
  },
  "taxConfiguration": null
}'

import http.client

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

payload = "{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}"

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

conn.request("POST", "/baseUrl/api/checkout/pvt/configuration/orderForm", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pvt/configuration/orderForm"

payload = {
    "allowManualPrice": None,
    "allowMultipleDeliveries": None,
    "apps": None,
    "decimalDigitsPrecision": 2,
    "minimumQuantityAccumulatedForItems": 1,
    "minimumValueAccumulated": None,
    "paymentConfiguration": { "requiresAuthenticationForPreAuthorizedPaymentOption": False },
    "taxConfiguration": None
}
headers = {
    "content-type": "application/json",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pvt/configuration/orderForm"

payload <- "{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\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/checkout/pvt/configuration/orderForm")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request["accept"] = ''
request.body = "{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\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/checkout/pvt/configuration/orderForm') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"allowManualPrice\": null,\n  \"allowMultipleDeliveries\": null,\n  \"apps\": null,\n  \"decimalDigitsPrecision\": 2,\n  \"minimumQuantityAccumulatedForItems\": 1,\n  \"minimumValueAccumulated\": null,\n  \"paymentConfiguration\": {\n    \"requiresAuthenticationForPreAuthorizedPaymentOption\": false\n  },\n  \"taxConfiguration\": null\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pvt/configuration/orderForm";

    let payload = json!({
        "allowManualPrice": json!(null),
        "allowMultipleDeliveries": json!(null),
        "apps": json!(null),
        "decimalDigitsPrecision": 2,
        "minimumQuantityAccumulatedForItems": 1,
        "minimumValueAccumulated": json!(null),
        "paymentConfiguration": json!({"requiresAuthenticationForPreAuthorizedPaymentOption": false}),
        "taxConfiguration": json!(null)
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());
    headers.insert("accept", "".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);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pvt/configuration/orderForm \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --data '{
  "allowManualPrice": null,
  "allowMultipleDeliveries": null,
  "apps": null,
  "decimalDigitsPrecision": 2,
  "minimumQuantityAccumulatedForItems": 1,
  "minimumValueAccumulated": null,
  "paymentConfiguration": {
    "requiresAuthenticationForPreAuthorizedPaymentOption": false
  },
  "taxConfiguration": null
}'

echo '{
  "allowManualPrice": null,
  "allowMultipleDeliveries": null,
  "apps": null,
  "decimalDigitsPrecision": 2,
  "minimumQuantityAccumulatedForItems": 1,
  "minimumValueAccumulated": null,
  "paymentConfiguration": {
    "requiresAuthenticationForPreAuthorizedPaymentOption": false
  },
  "taxConfiguration": null
}' |  \
  http POST {{baseUrl}}/api/checkout/pvt/configuration/orderForm \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --header 'accept: ' \
  --body-data '{\n  "allowManualPrice": null,\n  "allowMultipleDeliveries": null,\n  "apps": null,\n  "decimalDigitsPrecision": 2,\n  "minimumQuantityAccumulatedForItems": 1,\n  "minimumValueAccumulated": null,\n  "paymentConfiguration": {\n    "requiresAuthenticationForPreAuthorizedPaymentOption": false\n  },\n  "taxConfiguration": null\n}' \
  --output-document \
  - {{baseUrl}}/api/checkout/pvt/configuration/orderForm

import Foundation

let headers = [
  "content-type": "application/json",
  "accept": ""
]
let parameters = [
  "allowManualPrice": ,
  "allowMultipleDeliveries": ,
  "apps": ,
  "decimalDigitsPrecision": 2,
  "minimumQuantityAccumulatedForItems": 1,
  "minimumValueAccumulated": ,
  "paymentConfiguration": ["requiresAuthenticationForPreAuthorizedPaymentOption": false],
  "taxConfiguration": 
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pvt/configuration/orderForm")! 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()

POST Update window to change seller

{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller

HEADERS

Content-Type

BODY json

{
  "waitingTime": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller" {:headers {:accept ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:waitingTime 4}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"
headers = HTTP::Headers{
  "content-type" => "application/json"
  "accept" => ""
}
reqBody = "{\n  \"waitingTime\": 4\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/checkout/pvt/configuration/window-to-change-seller"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"waitingTime\": 4\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/checkout/pvt/configuration/window-to-change-seller");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddHeader("accept", "");
request.AddParameter("application/json", "{\n  \"waitingTime\": 4\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

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

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

	req.Header.Add("content-type", "application/json")
	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))

}

POST /baseUrl/api/checkout/pvt/configuration/window-to-change-seller HTTP/1.1
Content-Type: application/json
Accept: 
Host: example.com
Content-Length: 22

{
  "waitingTime": 4
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .setHeader("content-type", "application/json")
  .setHeader("accept", "")
  .setBody("{\n  \"waitingTime\": 4\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"))
    .header("content-type", "application/json")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"waitingTime\": 4\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  \"waitingTime\": 4\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .header("content-type", "application/json")
  .header("accept", "")
  .body("{\n  \"waitingTime\": 4\n}")
  .asString();

const data = JSON.stringify({
  waitingTime: 4
});

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/checkout/pvt/configuration/window-to-change-seller');
xhr.setRequestHeader('content-type', 'application/json');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': 'application/json', accept: ''},
  data: {waitingTime: 4}
};

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

const url = '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"waitingTime":4}'
};

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/checkout/pvt/configuration/window-to-change-seller',
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    accept: ''
  },
  processData: false,
  data: '{\n  "waitingTime": 4\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"waitingTime\": 4\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {
    'content-type': 'application/json',
    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.write(JSON.stringify({waitingTime: 4}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': 'application/json', accept: ''},
  body: {waitingTime: 4},
  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/checkout/pvt/configuration/window-to-change-seller');

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

req.type('json');
req.send({
  waitingTime: 4
});

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/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': 'application/json', accept: ''},
  data: {waitingTime: 4}
};

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

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

const url = '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"waitingTime":4}'
};

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"]
                                                       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/checkout/pvt/configuration/window-to-change-seller" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "application/json");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"waitingTime\": 4\n}" in

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

 "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller",
  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([
    'waitingTime' => 4
  ]),
  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/checkout/pvt/configuration/window-to-change-seller', [
  'body' => '{
  "waitingTime": 4
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'waitingTime' => 4
]));
$request->setRequestUrl('{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "waitingTime": 4
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "waitingTime": 4
}'

import http.client

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

payload = "{\n  \"waitingTime\": 4\n}"

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

conn.request("POST", "/baseUrl/api/checkout/pvt/configuration/window-to-change-seller", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

payload = { "waitingTime": 4 }
headers = {
    "content-type": "application/json",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

payload <- "{\n  \"waitingTime\": 4\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/checkout/pvt/configuration/window-to-change-seller")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request["accept"] = ''
request.body = "{\n  \"waitingTime\": 4\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/checkout/pvt/configuration/window-to-change-seller') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"waitingTime\": 4\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());
    headers.insert("accept", "".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);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --data '{
  "waitingTime": 4
}'

echo '{
  "waitingTime": 4
}' |  \
  http POST {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --header 'accept: ' \
  --body-data '{\n  "waitingTime": 4\n}' \
  --output-document \
  - {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")! 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()

DELETE Remove single custom field value

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName

HEADERS

Content-Type

QUERY PARAMS

orderFormId

appId

appFieldName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName");

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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName" {:headers {:content-type ""
                                                                                                                                :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"
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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"),
    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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName");
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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"

	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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"))
    .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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")
  .delete(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")
  .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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName';
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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  method: 'DELETE',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")
  .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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName');

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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName';
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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"]
                                                       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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName" 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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName",
  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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName');
$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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName');
$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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName' -Method DELETE -Headers $headers

import http.client

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

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

conn.request("DELETE", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")

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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName') 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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName \
  --header 'accept: ' \
  --header 'content-type: '

http DELETE {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName \
  accept:'' \
  content-type:''

wget --quiet \
  --method DELETE \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")! 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()

PUT Set multiple custom field values

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId

HEADERS

Content-Type

QUERY PARAMS

orderFormId

appId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId");

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/put "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId" {:headers {:content-type ""
                                                                                                               :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId"),
    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/checkout/pub/orderForm/:orderFormId/customData/:appId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId"

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

}

PUT /baseUrl/api/checkout/pub/orderForm/:orderFormId/customData/:appId HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId"))
    .header("content-type", "")
    .header("accept", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId")
  .put(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId")
  .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('PUT', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId';
const options = {method: 'PUT', 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/checkout/pub/orderForm/:orderFormId/customData/:appId',
  method: 'PUT',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId")
  .put(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/customData/:appId',
  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: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId',
  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('PUT', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId');

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: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId',
  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/checkout/pub/orderForm/:orderFormId/customData/:appId';
const options = {method: 'PUT', 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/checkout/pub/orderForm/:orderFormId/customData/:appId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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/checkout/pub/orderForm/:orderFormId/customData/:appId" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  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/checkout/pub/orderForm/:orderFormId/customData/:appId', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId');
$request->setMethod(HTTP_METH_PUT);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId');
$request->setRequestMethod('PUT');
$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/checkout/pub/orderForm/:orderFormId/customData/:appId' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId' -Method PUT -Headers $headers

import http.client

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

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

conn.request("PUT", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/customData/:appId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId")

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

request = Net::HTTP::Put.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.put('/baseUrl/api/checkout/pub/orderForm/:orderFormId/customData/:appId') 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/checkout/pub/orderForm/:orderFormId/customData/:appId";

    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("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId \
  --header 'accept: ' \
  --header 'content-type: '

http PUT {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId \
  accept:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Set single custom field value

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName

HEADERS

Content-Type

QUERY PARAMS

orderFormId

appId

appFieldName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName");

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/put "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName" {:headers {:content-type ""
                                                                                                                             :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"),
    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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"

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

}

PUT /baseUrl/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"))
    .header("content-type", "")
    .header("accept", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")
  .put(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")
  .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('PUT', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName';
const options = {method: 'PUT', 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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  method: 'PUT',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")
  .put(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  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: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  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('PUT', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName');

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: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName',
  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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName';
const options = {method: 'PUT', 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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName');
$request->setMethod(HTTP_METH_PUT);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName');
$request->setRequestMethod('PUT');
$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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName' -Method PUT -Headers $headers

import http.client

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

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

conn.request("PUT", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")

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

request = Net::HTTP::Put.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.put('/baseUrl/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName') 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/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName";

    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("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName \
  --header 'accept: ' \
  --header 'content-type: '

http PUT {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName \
  accept:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/customData/:appId/:appFieldName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

GET Get address by postal code

{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode

HEADERS

Content-Type

QUERY PARAMS

countryCode

postalCode

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode");

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/checkout/pub/postal-code/:countryCode/:postalCode" {:headers {:content-type ""
                                                                                                           :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode"
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/checkout/pub/postal-code/:countryCode/:postalCode"),
    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/checkout/pub/postal-code/:countryCode/:postalCode");
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/checkout/pub/postal-code/:countryCode/:postalCode"

	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/checkout/pub/postal-code/:countryCode/:postalCode HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode"))
    .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/checkout/pub/postal-code/:countryCode/:postalCode")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode")
  .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/checkout/pub/postal-code/:countryCode/:postalCode');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode';
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/checkout/pub/postal-code/:countryCode/:postalCode',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode")
  .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/checkout/pub/postal-code/:countryCode/:postalCode',
  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/checkout/pub/postal-code/:countryCode/:postalCode',
  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/checkout/pub/postal-code/:countryCode/:postalCode');

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/checkout/pub/postal-code/:countryCode/:postalCode',
  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/checkout/pub/postal-code/:countryCode/:postalCode';
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/checkout/pub/postal-code/:countryCode/:postalCode"]
                                                       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/checkout/pub/postal-code/:countryCode/:postalCode" 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/checkout/pub/postal-code/:countryCode/:postalCode",
  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/checkout/pub/postal-code/:countryCode/:postalCode', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode');
$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/checkout/pub/postal-code/:countryCode/:postalCode');
$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/checkout/pub/postal-code/:countryCode/:postalCode' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/api/checkout/pub/postal-code/:countryCode/:postalCode", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode")

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/checkout/pub/postal-code/:countryCode/:postalCode') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode";

    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);
}

curl --request GET \
  --url {{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/postal-code/:countryCode/:postalCode")! 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()

GET List pickup points by location

{{baseUrl}}/api/checkout/pub/pickup-points

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/pickup-points");

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/checkout/pub/pickup-points" {:headers {:content-type ""
                                                                                    :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/pickup-points"
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/checkout/pub/pickup-points"),
    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/checkout/pub/pickup-points");
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/checkout/pub/pickup-points"

	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/checkout/pub/pickup-points HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/checkout/pub/pickup-points")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/pickup-points"))
    .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/checkout/pub/pickup-points")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pub/pickup-points")
  .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/checkout/pub/pickup-points');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pub/pickup-points',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/pickup-points';
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/checkout/pub/pickup-points',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/pickup-points")
  .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/checkout/pub/pickup-points',
  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/checkout/pub/pickup-points',
  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/checkout/pub/pickup-points');

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/checkout/pub/pickup-points',
  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/checkout/pub/pickup-points';
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/checkout/pub/pickup-points"]
                                                       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/checkout/pub/pickup-points" 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/checkout/pub/pickup-points",
  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/checkout/pub/pickup-points', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/pickup-points');
$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/checkout/pub/pickup-points');
$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/checkout/pub/pickup-points' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/pickup-points' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/api/checkout/pub/pickup-points", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/pickup-points"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/pickup-points"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/pickup-points")

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/checkout/pub/pickup-points') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/pickup-points";

    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);
}

curl --request GET \
  --url {{baseUrl}}/api/checkout/pub/pickup-points \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/checkout/pub/pickup-points \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/pickup-points

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/pickup-points")! 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()

POST Place order from an existing cart

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction" {:headers {:content-type ""
                                                                                                          :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction"),
    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/checkout/pub/orderForm/:orderFormId/transaction");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/transaction HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/transaction',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/transaction',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction',
  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/checkout/pub/orderForm/:orderFormId/transaction';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/transaction"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/transaction" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/transaction', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/transaction' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/transaction", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/transaction') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/transaction")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

PUT Place order

{{baseUrl}}/api/checkout/pub/orders

HEADERS

Content-Type

BODY json

{
  "clientProfileData": {
    "corporateDocument": "",
    "corporateName": "",
    "corporatePhone": "",
    "document": "",
    "documentType": "",
    "email": "",
    "firstName": "",
    "isCorporate": false,
    "lastName": "",
    "phone": "",
    "stateInscription": "",
    "tradeName": ""
  },
  "items": [
    {
      "attachments": [],
      "bundleItems": [
        {
          "id": "",
          "name": "",
          "price": 0,
          "type": ""
        }
      ],
      "commission": 0,
      "freightCommission": 0,
      "id": "",
      "isGift": false,
      "itemAttachment": {
        "content": "",
        "name": ""
      },
      "measurementUnit": "",
      "price": 0,
      "priceTags": [
        {
          "identifier": "",
          "isPercentual": false,
          "name": "",
          "rawValue": 0,
          "value": 0
        }
      ],
      "quantity": 0,
      "seller": "",
      "unitMultiplier": 0
    }
  ],
  "marketingData": {
    "coupon": "",
    "utmCampaign": "",
    "utmMedium": "",
    "utmSource": "",
    "utmiCampaign": "",
    "utmiPage": "",
    "utmiPart": ""
  },
  "openTextField": "",
  "paymentData": {
    "giftCardMessages": [],
    "giftCards": [
      {
        "balance": 0,
        "id": "",
        "inUse": false,
        "isSpecialCard": false,
        "name": "",
        "redemptionCode": "",
        "value": 0
      }
    ],
    "paymentSystems": [
      {
        "description": "",
        "groupName": "",
        "id": 0,
        "isCustom": false,
        "name": "",
        "requiresDocument": false,
        "selected": false,
        "stringId": "",
        "template": "",
        "validator": {
          "cardCodeMask": "",
          "cardCodeRegex": "",
          "mask": "",
          "regex": "",
          "weights": []
        }
      }
    ],
    "payments": [
      {
        "accountId": "",
        "bin": "",
        "installments": 0,
        "paymentSystem": "",
        "referenceValue": 0,
        "value": 0
      }
    ],
    "updateStatus": ""
  },
  "salesAssociateData": {
    "salesAssociateId": ""
  },
  "shippingData": {
    "address": {
      "addressId": "",
      "addressType": "",
      "city": "",
      "complement": "",
      "country": "",
      "geoCoordinates": [],
      "neighborhood": "",
      "number": "",
      "postalCode": "",
      "receiverName": "",
      "reference": "",
      "state": "",
      "street": ""
    },
    "logisticsInfo": [
      {
        "deliveryWindow": {
          "endDateUtc": "",
          "lisPrice": 0,
          "price": 0,
          "startDateUtc": "",
          "tax": 0
        },
        "itemIndex": 0,
        "lockTTL": "",
        "price": 0,
        "selectedSla": "",
        "shippingEstimate": ""
      }
    ],
    "updateStatus": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orders");

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);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/checkout/pub/orders" {:headers {:accept ""}
                                                                   :content-type :json
                                                                   :form-params {:clientProfileData {:corporateDocument ""
                                                                                                     :corporateName ""
                                                                                                     :corporatePhone ""
                                                                                                     :document ""
                                                                                                     :documentType ""
                                                                                                     :email ""
                                                                                                     :firstName ""
                                                                                                     :isCorporate false
                                                                                                     :lastName ""
                                                                                                     :phone ""
                                                                                                     :stateInscription ""
                                                                                                     :tradeName ""}
                                                                                 :items [{:attachments []
                                                                                          :bundleItems [{:id ""
                                                                                                         :name ""
                                                                                                         :price 0
                                                                                                         :type ""}]
                                                                                          :commission 0
                                                                                          :freightCommission 0
                                                                                          :id ""
                                                                                          :isGift false
                                                                                          :itemAttachment {:content ""
                                                                                                           :name ""}
                                                                                          :measurementUnit ""
                                                                                          :price 0
                                                                                          :priceTags [{:identifier ""
                                                                                                       :isPercentual false
                                                                                                       :name ""
                                                                                                       :rawValue 0
                                                                                                       :value 0}]
                                                                                          :quantity 0
                                                                                          :seller ""
                                                                                          :unitMultiplier 0}]
                                                                                 :marketingData {:coupon ""
                                                                                                 :utmCampaign ""
                                                                                                 :utmMedium ""
                                                                                                 :utmSource ""
                                                                                                 :utmiCampaign ""
                                                                                                 :utmiPage ""
                                                                                                 :utmiPart ""}
                                                                                 :openTextField ""
                                                                                 :paymentData {:giftCardMessages []
                                                                                               :giftCards [{:balance 0
                                                                                                            :id ""
                                                                                                            :inUse false
                                                                                                            :isSpecialCard false
                                                                                                            :name ""
                                                                                                            :redemptionCode ""
                                                                                                            :value 0}]
                                                                                               :paymentSystems [{:description ""
                                                                                                                 :groupName ""
                                                                                                                 :id 0
                                                                                                                 :isCustom false
                                                                                                                 :name ""
                                                                                                                 :requiresDocument false
                                                                                                                 :selected false
                                                                                                                 :stringId ""
                                                                                                                 :template ""
                                                                                                                 :validator {:cardCodeMask ""
                                                                                                                             :cardCodeRegex ""
                                                                                                                             :mask ""
                                                                                                                             :regex ""
                                                                                                                             :weights []}}]
                                                                                               :payments [{:accountId ""
                                                                                                           :bin ""
                                                                                                           :installments 0
                                                                                                           :paymentSystem ""
                                                                                                           :referenceValue 0
                                                                                                           :value 0}]
                                                                                               :updateStatus ""}
                                                                                 :salesAssociateData {:salesAssociateId ""}
                                                                                 :shippingData {:address {:addressId ""
                                                                                                          :addressType ""
                                                                                                          :city ""
                                                                                                          :complement ""
                                                                                                          :country ""
                                                                                                          :geoCoordinates []
                                                                                                          :neighborhood ""
                                                                                                          :number ""
                                                                                                          :postalCode ""
                                                                                                          :receiverName ""
                                                                                                          :reference ""
                                                                                                          :state ""
                                                                                                          :street ""}
                                                                                                :logisticsInfo [{:deliveryWindow {:endDateUtc ""
                                                                                                                                  :lisPrice 0
                                                                                                                                  :price 0
                                                                                                                                  :startDateUtc ""
                                                                                                                                  :tax 0}
                                                                                                                 :itemIndex 0
                                                                                                                 :lockTTL ""
                                                                                                                 :price 0
                                                                                                                 :selectedSla ""
                                                                                                                 :shippingEstimate ""}]
                                                                                                :updateStatus ""}}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orders"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}
reqBody = "{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orders"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\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/checkout/pub/orders");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
request.AddParameter("", "{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orders"

	payload := strings.NewReader("{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}")

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

	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))

}

PUT /baseUrl/api/checkout/pub/orders HTTP/1.1
Content-Type: 
Accept: 
Host: example.com
Content-Length: 2821

{
  "clientProfileData": {
    "corporateDocument": "",
    "corporateName": "",
    "corporatePhone": "",
    "document": "",
    "documentType": "",
    "email": "",
    "firstName": "",
    "isCorporate": false,
    "lastName": "",
    "phone": "",
    "stateInscription": "",
    "tradeName": ""
  },
  "items": [
    {
      "attachments": [],
      "bundleItems": [
        {
          "id": "",
          "name": "",
          "price": 0,
          "type": ""
        }
      ],
      "commission": 0,
      "freightCommission": 0,
      "id": "",
      "isGift": false,
      "itemAttachment": {
        "content": "",
        "name": ""
      },
      "measurementUnit": "",
      "price": 0,
      "priceTags": [
        {
          "identifier": "",
          "isPercentual": false,
          "name": "",
          "rawValue": 0,
          "value": 0
        }
      ],
      "quantity": 0,
      "seller": "",
      "unitMultiplier": 0
    }
  ],
  "marketingData": {
    "coupon": "",
    "utmCampaign": "",
    "utmMedium": "",
    "utmSource": "",
    "utmiCampaign": "",
    "utmiPage": "",
    "utmiPart": ""
  },
  "openTextField": "",
  "paymentData": {
    "giftCardMessages": [],
    "giftCards": [
      {
        "balance": 0,
        "id": "",
        "inUse": false,
        "isSpecialCard": false,
        "name": "",
        "redemptionCode": "",
        "value": 0
      }
    ],
    "paymentSystems": [
      {
        "description": "",
        "groupName": "",
        "id": 0,
        "isCustom": false,
        "name": "",
        "requiresDocument": false,
        "selected": false,
        "stringId": "",
        "template": "",
        "validator": {
          "cardCodeMask": "",
          "cardCodeRegex": "",
          "mask": "",
          "regex": "",
          "weights": []
        }
      }
    ],
    "payments": [
      {
        "accountId": "",
        "bin": "",
        "installments": 0,
        "paymentSystem": "",
        "referenceValue": 0,
        "value": 0
      }
    ],
    "updateStatus": ""
  },
  "salesAssociateData": {
    "salesAssociateId": ""
  },
  "shippingData": {
    "address": {
      "addressId": "",
      "addressType": "",
      "city": "",
      "complement": "",
      "country": "",
      "geoCoordinates": [],
      "neighborhood": "",
      "number": "",
      "postalCode": "",
      "receiverName": "",
      "reference": "",
      "state": "",
      "street": ""
    },
    "logisticsInfo": [
      {
        "deliveryWindow": {
          "endDateUtc": "",
          "lisPrice": 0,
          "price": 0,
          "startDateUtc": "",
          "tax": 0
        },
        "itemIndex": 0,
        "lockTTL": "",
        "price": 0,
        "selectedSla": "",
        "shippingEstimate": ""
      }
    ],
    "updateStatus": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/checkout/pub/orders")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .setBody("{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orders"))
    .header("content-type", "")
    .header("accept", "")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\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  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orders")
  .put(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/checkout/pub/orders")
  .header("content-type", "")
  .header("accept", "")
  .body("{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  clientProfileData: {
    corporateDocument: '',
    corporateName: '',
    corporatePhone: '',
    document: '',
    documentType: '',
    email: '',
    firstName: '',
    isCorporate: false,
    lastName: '',
    phone: '',
    stateInscription: '',
    tradeName: ''
  },
  items: [
    {
      attachments: [],
      bundleItems: [
        {
          id: '',
          name: '',
          price: 0,
          type: ''
        }
      ],
      commission: 0,
      freightCommission: 0,
      id: '',
      isGift: false,
      itemAttachment: {
        content: '',
        name: ''
      },
      measurementUnit: '',
      price: 0,
      priceTags: [
        {
          identifier: '',
          isPercentual: false,
          name: '',
          rawValue: 0,
          value: 0
        }
      ],
      quantity: 0,
      seller: '',
      unitMultiplier: 0
    }
  ],
  marketingData: {
    coupon: '',
    utmCampaign: '',
    utmMedium: '',
    utmSource: '',
    utmiCampaign: '',
    utmiPage: '',
    utmiPart: ''
  },
  openTextField: '',
  paymentData: {
    giftCardMessages: [],
    giftCards: [
      {
        balance: 0,
        id: '',
        inUse: false,
        isSpecialCard: false,
        name: '',
        redemptionCode: '',
        value: 0
      }
    ],
    paymentSystems: [
      {
        description: '',
        groupName: '',
        id: 0,
        isCustom: false,
        name: '',
        requiresDocument: false,
        selected: false,
        stringId: '',
        template: '',
        validator: {
          cardCodeMask: '',
          cardCodeRegex: '',
          mask: '',
          regex: '',
          weights: []
        }
      }
    ],
    payments: [
      {
        accountId: '',
        bin: '',
        installments: 0,
        paymentSystem: '',
        referenceValue: 0,
        value: 0
      }
    ],
    updateStatus: ''
  },
  salesAssociateData: {
    salesAssociateId: ''
  },
  shippingData: {
    address: {
      addressId: '',
      addressType: '',
      city: '',
      complement: '',
      country: '',
      geoCoordinates: [],
      neighborhood: '',
      number: '',
      postalCode: '',
      receiverName: '',
      reference: '',
      state: '',
      street: ''
    },
    logisticsInfo: [
      {
        deliveryWindow: {
          endDateUtc: '',
          lisPrice: 0,
          price: 0,
          startDateUtc: '',
          tax: 0
        },
        itemIndex: 0,
        lockTTL: '',
        price: 0,
        selectedSla: '',
        shippingEstimate: ''
      }
    ],
    updateStatus: ''
  }
});

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/checkout/pub/orders');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orders',
  headers: {'content-type': '', accept: ''},
  data: {
    clientProfileData: {
      corporateDocument: '',
      corporateName: '',
      corporatePhone: '',
      document: '',
      documentType: '',
      email: '',
      firstName: '',
      isCorporate: false,
      lastName: '',
      phone: '',
      stateInscription: '',
      tradeName: ''
    },
    items: [
      {
        attachments: [],
        bundleItems: [{id: '', name: '', price: 0, type: ''}],
        commission: 0,
        freightCommission: 0,
        id: '',
        isGift: false,
        itemAttachment: {content: '', name: ''},
        measurementUnit: '',
        price: 0,
        priceTags: [{identifier: '', isPercentual: false, name: '', rawValue: 0, value: 0}],
        quantity: 0,
        seller: '',
        unitMultiplier: 0
      }
    ],
    marketingData: {
      coupon: '',
      utmCampaign: '',
      utmMedium: '',
      utmSource: '',
      utmiCampaign: '',
      utmiPage: '',
      utmiPart: ''
    },
    openTextField: '',
    paymentData: {
      giftCardMessages: [],
      giftCards: [
        {
          balance: 0,
          id: '',
          inUse: false,
          isSpecialCard: false,
          name: '',
          redemptionCode: '',
          value: 0
        }
      ],
      paymentSystems: [
        {
          description: '',
          groupName: '',
          id: 0,
          isCustom: false,
          name: '',
          requiresDocument: false,
          selected: false,
          stringId: '',
          template: '',
          validator: {cardCodeMask: '', cardCodeRegex: '', mask: '', regex: '', weights: []}
        }
      ],
      payments: [
        {
          accountId: '',
          bin: '',
          installments: 0,
          paymentSystem: '',
          referenceValue: 0,
          value: 0
        }
      ],
      updateStatus: ''
    },
    salesAssociateData: {salesAssociateId: ''},
    shippingData: {
      address: {
        addressId: '',
        addressType: '',
        city: '',
        complement: '',
        country: '',
        geoCoordinates: [],
        neighborhood: '',
        number: '',
        postalCode: '',
        receiverName: '',
        reference: '',
        state: '',
        street: ''
      },
      logisticsInfo: [
        {
          deliveryWindow: {endDateUtc: '', lisPrice: 0, price: 0, startDateUtc: '', tax: 0},
          itemIndex: 0,
          lockTTL: '',
          price: 0,
          selectedSla: '',
          shippingEstimate: ''
        }
      ],
      updateStatus: ''
    }
  }
};

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

const url = '{{baseUrl}}/api/checkout/pub/orders';
const options = {
  method: 'PUT',
  headers: {'content-type': '', accept: ''},
  body: '{"clientProfileData":{"corporateDocument":"","corporateName":"","corporatePhone":"","document":"","documentType":"","email":"","firstName":"","isCorporate":false,"lastName":"","phone":"","stateInscription":"","tradeName":""},"items":[{"attachments":[],"bundleItems":[{"id":"","name":"","price":0,"type":""}],"commission":0,"freightCommission":0,"id":"","isGift":false,"itemAttachment":{"content":"","name":""},"measurementUnit":"","price":0,"priceTags":[{"identifier":"","isPercentual":false,"name":"","rawValue":0,"value":0}],"quantity":0,"seller":"","unitMultiplier":0}],"marketingData":{"coupon":"","utmCampaign":"","utmMedium":"","utmSource":"","utmiCampaign":"","utmiPage":"","utmiPart":""},"openTextField":"","paymentData":{"giftCardMessages":[],"giftCards":[{"balance":0,"id":"","inUse":false,"isSpecialCard":false,"name":"","redemptionCode":"","value":0}],"paymentSystems":[{"description":"","groupName":"","id":0,"isCustom":false,"name":"","requiresDocument":false,"selected":false,"stringId":"","template":"","validator":{"cardCodeMask":"","cardCodeRegex":"","mask":"","regex":"","weights":[]}}],"payments":[{"accountId":"","bin":"","installments":0,"paymentSystem":"","referenceValue":0,"value":0}],"updateStatus":""},"salesAssociateData":{"salesAssociateId":""},"shippingData":{"address":{"addressId":"","addressType":"","city":"","complement":"","country":"","geoCoordinates":[],"neighborhood":"","number":"","postalCode":"","receiverName":"","reference":"","state":"","street":""},"logisticsInfo":[{"deliveryWindow":{"endDateUtc":"","lisPrice":0,"price":0,"startDateUtc":"","tax":0},"itemIndex":0,"lockTTL":"","price":0,"selectedSla":"","shippingEstimate":""}],"updateStatus":""}}'
};

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/checkout/pub/orders',
  method: 'PUT',
  headers: {
    'content-type': '',
    accept: ''
  },
  processData: false,
  data: '{\n  "clientProfileData": {\n    "corporateDocument": "",\n    "corporateName": "",\n    "corporatePhone": "",\n    "document": "",\n    "documentType": "",\n    "email": "",\n    "firstName": "",\n    "isCorporate": false,\n    "lastName": "",\n    "phone": "",\n    "stateInscription": "",\n    "tradeName": ""\n  },\n  "items": [\n    {\n      "attachments": [],\n      "bundleItems": [\n        {\n          "id": "",\n          "name": "",\n          "price": 0,\n          "type": ""\n        }\n      ],\n      "commission": 0,\n      "freightCommission": 0,\n      "id": "",\n      "isGift": false,\n      "itemAttachment": {\n        "content": "",\n        "name": ""\n      },\n      "measurementUnit": "",\n      "price": 0,\n      "priceTags": [\n        {\n          "identifier": "",\n          "isPercentual": false,\n          "name": "",\n          "rawValue": 0,\n          "value": 0\n        }\n      ],\n      "quantity": 0,\n      "seller": "",\n      "unitMultiplier": 0\n    }\n  ],\n  "marketingData": {\n    "coupon": "",\n    "utmCampaign": "",\n    "utmMedium": "",\n    "utmSource": "",\n    "utmiCampaign": "",\n    "utmiPage": "",\n    "utmiPart": ""\n  },\n  "openTextField": "",\n  "paymentData": {\n    "giftCardMessages": [],\n    "giftCards": [\n      {\n        "balance": 0,\n        "id": "",\n        "inUse": false,\n        "isSpecialCard": false,\n        "name": "",\n        "redemptionCode": "",\n        "value": 0\n      }\n    ],\n    "paymentSystems": [\n      {\n        "description": "",\n        "groupName": "",\n        "id": 0,\n        "isCustom": false,\n        "name": "",\n        "requiresDocument": false,\n        "selected": false,\n        "stringId": "",\n        "template": "",\n        "validator": {\n          "cardCodeMask": "",\n          "cardCodeRegex": "",\n          "mask": "",\n          "regex": "",\n          "weights": []\n        }\n      }\n    ],\n    "payments": [\n      {\n        "accountId": "",\n        "bin": "",\n        "installments": 0,\n        "paymentSystem": "",\n        "referenceValue": 0,\n        "value": 0\n      }\n    ],\n    "updateStatus": ""\n  },\n  "salesAssociateData": {\n    "salesAssociateId": ""\n  },\n  "shippingData": {\n    "address": {\n      "addressId": "",\n      "addressType": "",\n      "city": "",\n      "complement": "",\n      "country": "",\n      "geoCoordinates": [],\n      "neighborhood": "",\n      "number": "",\n      "postalCode": "",\n      "receiverName": "",\n      "reference": "",\n      "state": "",\n      "street": ""\n    },\n    "logisticsInfo": [\n      {\n        "deliveryWindow": {\n          "endDateUtc": "",\n          "lisPrice": 0,\n          "price": 0,\n          "startDateUtc": "",\n          "tax": 0\n        },\n        "itemIndex": 0,\n        "lockTTL": "",\n        "price": 0,\n        "selectedSla": "",\n        "shippingEstimate": ""\n      }\n    ],\n    "updateStatus": ""\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  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orders")
  .put(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orders',
  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.write(JSON.stringify({
  clientProfileData: {
    corporateDocument: '',
    corporateName: '',
    corporatePhone: '',
    document: '',
    documentType: '',
    email: '',
    firstName: '',
    isCorporate: false,
    lastName: '',
    phone: '',
    stateInscription: '',
    tradeName: ''
  },
  items: [
    {
      attachments: [],
      bundleItems: [{id: '', name: '', price: 0, type: ''}],
      commission: 0,
      freightCommission: 0,
      id: '',
      isGift: false,
      itemAttachment: {content: '', name: ''},
      measurementUnit: '',
      price: 0,
      priceTags: [{identifier: '', isPercentual: false, name: '', rawValue: 0, value: 0}],
      quantity: 0,
      seller: '',
      unitMultiplier: 0
    }
  ],
  marketingData: {
    coupon: '',
    utmCampaign: '',
    utmMedium: '',
    utmSource: '',
    utmiCampaign: '',
    utmiPage: '',
    utmiPart: ''
  },
  openTextField: '',
  paymentData: {
    giftCardMessages: [],
    giftCards: [
      {
        balance: 0,
        id: '',
        inUse: false,
        isSpecialCard: false,
        name: '',
        redemptionCode: '',
        value: 0
      }
    ],
    paymentSystems: [
      {
        description: '',
        groupName: '',
        id: 0,
        isCustom: false,
        name: '',
        requiresDocument: false,
        selected: false,
        stringId: '',
        template: '',
        validator: {cardCodeMask: '', cardCodeRegex: '', mask: '', regex: '', weights: []}
      }
    ],
    payments: [
      {
        accountId: '',
        bin: '',
        installments: 0,
        paymentSystem: '',
        referenceValue: 0,
        value: 0
      }
    ],
    updateStatus: ''
  },
  salesAssociateData: {salesAssociateId: ''},
  shippingData: {
    address: {
      addressId: '',
      addressType: '',
      city: '',
      complement: '',
      country: '',
      geoCoordinates: [],
      neighborhood: '',
      number: '',
      postalCode: '',
      receiverName: '',
      reference: '',
      state: '',
      street: ''
    },
    logisticsInfo: [
      {
        deliveryWindow: {endDateUtc: '', lisPrice: 0, price: 0, startDateUtc: '', tax: 0},
        itemIndex: 0,
        lockTTL: '',
        price: 0,
        selectedSla: '',
        shippingEstimate: ''
      }
    ],
    updateStatus: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orders',
  headers: {'content-type': '', accept: ''},
  body: {
    clientProfileData: {
      corporateDocument: '',
      corporateName: '',
      corporatePhone: '',
      document: '',
      documentType: '',
      email: '',
      firstName: '',
      isCorporate: false,
      lastName: '',
      phone: '',
      stateInscription: '',
      tradeName: ''
    },
    items: [
      {
        attachments: [],
        bundleItems: [{id: '', name: '', price: 0, type: ''}],
        commission: 0,
        freightCommission: 0,
        id: '',
        isGift: false,
        itemAttachment: {content: '', name: ''},
        measurementUnit: '',
        price: 0,
        priceTags: [{identifier: '', isPercentual: false, name: '', rawValue: 0, value: 0}],
        quantity: 0,
        seller: '',
        unitMultiplier: 0
      }
    ],
    marketingData: {
      coupon: '',
      utmCampaign: '',
      utmMedium: '',
      utmSource: '',
      utmiCampaign: '',
      utmiPage: '',
      utmiPart: ''
    },
    openTextField: '',
    paymentData: {
      giftCardMessages: [],
      giftCards: [
        {
          balance: 0,
          id: '',
          inUse: false,
          isSpecialCard: false,
          name: '',
          redemptionCode: '',
          value: 0
        }
      ],
      paymentSystems: [
        {
          description: '',
          groupName: '',
          id: 0,
          isCustom: false,
          name: '',
          requiresDocument: false,
          selected: false,
          stringId: '',
          template: '',
          validator: {cardCodeMask: '', cardCodeRegex: '', mask: '', regex: '', weights: []}
        }
      ],
      payments: [
        {
          accountId: '',
          bin: '',
          installments: 0,
          paymentSystem: '',
          referenceValue: 0,
          value: 0
        }
      ],
      updateStatus: ''
    },
    salesAssociateData: {salesAssociateId: ''},
    shippingData: {
      address: {
        addressId: '',
        addressType: '',
        city: '',
        complement: '',
        country: '',
        geoCoordinates: [],
        neighborhood: '',
        number: '',
        postalCode: '',
        receiverName: '',
        reference: '',
        state: '',
        street: ''
      },
      logisticsInfo: [
        {
          deliveryWindow: {endDateUtc: '', lisPrice: 0, price: 0, startDateUtc: '', tax: 0},
          itemIndex: 0,
          lockTTL: '',
          price: 0,
          selectedSla: '',
          shippingEstimate: ''
        }
      ],
      updateStatus: ''
    }
  },
  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/checkout/pub/orders');

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

req.type('json');
req.send({
  clientProfileData: {
    corporateDocument: '',
    corporateName: '',
    corporatePhone: '',
    document: '',
    documentType: '',
    email: '',
    firstName: '',
    isCorporate: false,
    lastName: '',
    phone: '',
    stateInscription: '',
    tradeName: ''
  },
  items: [
    {
      attachments: [],
      bundleItems: [
        {
          id: '',
          name: '',
          price: 0,
          type: ''
        }
      ],
      commission: 0,
      freightCommission: 0,
      id: '',
      isGift: false,
      itemAttachment: {
        content: '',
        name: ''
      },
      measurementUnit: '',
      price: 0,
      priceTags: [
        {
          identifier: '',
          isPercentual: false,
          name: '',
          rawValue: 0,
          value: 0
        }
      ],
      quantity: 0,
      seller: '',
      unitMultiplier: 0
    }
  ],
  marketingData: {
    coupon: '',
    utmCampaign: '',
    utmMedium: '',
    utmSource: '',
    utmiCampaign: '',
    utmiPage: '',
    utmiPart: ''
  },
  openTextField: '',
  paymentData: {
    giftCardMessages: [],
    giftCards: [
      {
        balance: 0,
        id: '',
        inUse: false,
        isSpecialCard: false,
        name: '',
        redemptionCode: '',
        value: 0
      }
    ],
    paymentSystems: [
      {
        description: '',
        groupName: '',
        id: 0,
        isCustom: false,
        name: '',
        requiresDocument: false,
        selected: false,
        stringId: '',
        template: '',
        validator: {
          cardCodeMask: '',
          cardCodeRegex: '',
          mask: '',
          regex: '',
          weights: []
        }
      }
    ],
    payments: [
      {
        accountId: '',
        bin: '',
        installments: 0,
        paymentSystem: '',
        referenceValue: 0,
        value: 0
      }
    ],
    updateStatus: ''
  },
  salesAssociateData: {
    salesAssociateId: ''
  },
  shippingData: {
    address: {
      addressId: '',
      addressType: '',
      city: '',
      complement: '',
      country: '',
      geoCoordinates: [],
      neighborhood: '',
      number: '',
      postalCode: '',
      receiverName: '',
      reference: '',
      state: '',
      street: ''
    },
    logisticsInfo: [
      {
        deliveryWindow: {
          endDateUtc: '',
          lisPrice: 0,
          price: 0,
          startDateUtc: '',
          tax: 0
        },
        itemIndex: 0,
        lockTTL: '',
        price: 0,
        selectedSla: '',
        shippingEstimate: ''
      }
    ],
    updateStatus: ''
  }
});

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/checkout/pub/orders',
  headers: {'content-type': '', accept: ''},
  data: {
    clientProfileData: {
      corporateDocument: '',
      corporateName: '',
      corporatePhone: '',
      document: '',
      documentType: '',
      email: '',
      firstName: '',
      isCorporate: false,
      lastName: '',
      phone: '',
      stateInscription: '',
      tradeName: ''
    },
    items: [
      {
        attachments: [],
        bundleItems: [{id: '', name: '', price: 0, type: ''}],
        commission: 0,
        freightCommission: 0,
        id: '',
        isGift: false,
        itemAttachment: {content: '', name: ''},
        measurementUnit: '',
        price: 0,
        priceTags: [{identifier: '', isPercentual: false, name: '', rawValue: 0, value: 0}],
        quantity: 0,
        seller: '',
        unitMultiplier: 0
      }
    ],
    marketingData: {
      coupon: '',
      utmCampaign: '',
      utmMedium: '',
      utmSource: '',
      utmiCampaign: '',
      utmiPage: '',
      utmiPart: ''
    },
    openTextField: '',
    paymentData: {
      giftCardMessages: [],
      giftCards: [
        {
          balance: 0,
          id: '',
          inUse: false,
          isSpecialCard: false,
          name: '',
          redemptionCode: '',
          value: 0
        }
      ],
      paymentSystems: [
        {
          description: '',
          groupName: '',
          id: 0,
          isCustom: false,
          name: '',
          requiresDocument: false,
          selected: false,
          stringId: '',
          template: '',
          validator: {cardCodeMask: '', cardCodeRegex: '', mask: '', regex: '', weights: []}
        }
      ],
      payments: [
        {
          accountId: '',
          bin: '',
          installments: 0,
          paymentSystem: '',
          referenceValue: 0,
          value: 0
        }
      ],
      updateStatus: ''
    },
    salesAssociateData: {salesAssociateId: ''},
    shippingData: {
      address: {
        addressId: '',
        addressType: '',
        city: '',
        complement: '',
        country: '',
        geoCoordinates: [],
        neighborhood: '',
        number: '',
        postalCode: '',
        receiverName: '',
        reference: '',
        state: '',
        street: ''
      },
      logisticsInfo: [
        {
          deliveryWindow: {endDateUtc: '', lisPrice: 0, price: 0, startDateUtc: '', tax: 0},
          itemIndex: 0,
          lockTTL: '',
          price: 0,
          selectedSla: '',
          shippingEstimate: ''
        }
      ],
      updateStatus: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/api/checkout/pub/orders';
const options = {
  method: 'PUT',
  headers: {'content-type': '', accept: ''},
  body: '{"clientProfileData":{"corporateDocument":"","corporateName":"","corporatePhone":"","document":"","documentType":"","email":"","firstName":"","isCorporate":false,"lastName":"","phone":"","stateInscription":"","tradeName":""},"items":[{"attachments":[],"bundleItems":[{"id":"","name":"","price":0,"type":""}],"commission":0,"freightCommission":0,"id":"","isGift":false,"itemAttachment":{"content":"","name":""},"measurementUnit":"","price":0,"priceTags":[{"identifier":"","isPercentual":false,"name":"","rawValue":0,"value":0}],"quantity":0,"seller":"","unitMultiplier":0}],"marketingData":{"coupon":"","utmCampaign":"","utmMedium":"","utmSource":"","utmiCampaign":"","utmiPage":"","utmiPart":""},"openTextField":"","paymentData":{"giftCardMessages":[],"giftCards":[{"balance":0,"id":"","inUse":false,"isSpecialCard":false,"name":"","redemptionCode":"","value":0}],"paymentSystems":[{"description":"","groupName":"","id":0,"isCustom":false,"name":"","requiresDocument":false,"selected":false,"stringId":"","template":"","validator":{"cardCodeMask":"","cardCodeRegex":"","mask":"","regex":"","weights":[]}}],"payments":[{"accountId":"","bin":"","installments":0,"paymentSystem":"","referenceValue":0,"value":0}],"updateStatus":""},"salesAssociateData":{"salesAssociateId":""},"shippingData":{"address":{"addressId":"","addressType":"","city":"","complement":"","country":"","geoCoordinates":[],"neighborhood":"","number":"","postalCode":"","receiverName":"","reference":"","state":"","street":""},"logisticsInfo":[{"deliveryWindow":{"endDateUtc":"","lisPrice":0,"price":0,"startDateUtc":"","tax":0},"itemIndex":0,"lockTTL":"","price":0,"selectedSla":"","shippingEstimate":""}],"updateStatus":""}}'
};

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": @"" };
NSDictionary *parameters = @{ @"clientProfileData": @{ @"corporateDocument": @"", @"corporateName": @"", @"corporatePhone": @"", @"document": @"", @"documentType": @"", @"email": @"", @"firstName": @"", @"isCorporate": @NO, @"lastName": @"", @"phone": @"", @"stateInscription": @"", @"tradeName": @"" },
                              @"items": @[ @{ @"attachments": @[  ], @"bundleItems": @[ @{ @"id": @"", @"name": @"", @"price": @0, @"type": @"" } ], @"commission": @0, @"freightCommission": @0, @"id": @"", @"isGift": @NO, @"itemAttachment": @{ @"content": @"", @"name": @"" }, @"measurementUnit": @"", @"price": @0, @"priceTags": @[ @{ @"identifier": @"", @"isPercentual": @NO, @"name": @"", @"rawValue": @0, @"value": @0 } ], @"quantity": @0, @"seller": @"", @"unitMultiplier": @0 } ],
                              @"marketingData": @{ @"coupon": @"", @"utmCampaign": @"", @"utmMedium": @"", @"utmSource": @"", @"utmiCampaign": @"", @"utmiPage": @"", @"utmiPart": @"" },
                              @"openTextField": @"",
                              @"paymentData": @{ @"giftCardMessages": @[  ], @"giftCards": @[ @{ @"balance": @0, @"id": @"", @"inUse": @NO, @"isSpecialCard": @NO, @"name": @"", @"redemptionCode": @"", @"value": @0 } ], @"paymentSystems": @[ @{ @"description": @"", @"groupName": @"", @"id": @0, @"isCustom": @NO, @"name": @"", @"requiresDocument": @NO, @"selected": @NO, @"stringId": @"", @"template": @"", @"validator": @{ @"cardCodeMask": @"", @"cardCodeRegex": @"", @"mask": @"", @"regex": @"", @"weights": @[  ] } } ], @"payments": @[ @{ @"accountId": @"", @"bin": @"", @"installments": @0, @"paymentSystem": @"", @"referenceValue": @0, @"value": @0 } ], @"updateStatus": @"" },
                              @"salesAssociateData": @{ @"salesAssociateId": @"" },
                              @"shippingData": @{ @"address": @{ @"addressId": @"", @"addressType": @"", @"city": @"", @"complement": @"", @"country": @"", @"geoCoordinates": @[  ], @"neighborhood": @"", @"number": @"", @"postalCode": @"", @"receiverName": @"", @"reference": @"", @"state": @"", @"street": @"" }, @"logisticsInfo": @[ @{ @"deliveryWindow": @{ @"endDateUtc": @"", @"lisPrice": @0, @"price": @0, @"startDateUtc": @"", @"tax": @0 }, @"itemIndex": @0, @"lockTTL": @"", @"price": @0, @"selectedSla": @"", @"shippingEstimate": @"" } ], @"updateStatus": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/checkout/pub/orders"]
                                                       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/checkout/pub/orders" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/api/checkout/pub/orders",
  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([
    'clientProfileData' => [
        'corporateDocument' => '',
        'corporateName' => '',
        'corporatePhone' => '',
        'document' => '',
        'documentType' => '',
        'email' => '',
        'firstName' => '',
        'isCorporate' => null,
        'lastName' => '',
        'phone' => '',
        'stateInscription' => '',
        'tradeName' => ''
    ],
    'items' => [
        [
                'attachments' => [
                                
                ],
                'bundleItems' => [
                                [
                                                                'id' => '',
                                                                'name' => '',
                                                                'price' => 0,
                                                                'type' => ''
                                ]
                ],
                'commission' => 0,
                'freightCommission' => 0,
                'id' => '',
                'isGift' => null,
                'itemAttachment' => [
                                'content' => '',
                                'name' => ''
                ],
                'measurementUnit' => '',
                'price' => 0,
                'priceTags' => [
                                [
                                                                'identifier' => '',
                                                                'isPercentual' => null,
                                                                'name' => '',
                                                                'rawValue' => 0,
                                                                'value' => 0
                                ]
                ],
                'quantity' => 0,
                'seller' => '',
                'unitMultiplier' => 0
        ]
    ],
    'marketingData' => [
        'coupon' => '',
        'utmCampaign' => '',
        'utmMedium' => '',
        'utmSource' => '',
        'utmiCampaign' => '',
        'utmiPage' => '',
        'utmiPart' => ''
    ],
    'openTextField' => '',
    'paymentData' => [
        'giftCardMessages' => [
                
        ],
        'giftCards' => [
                [
                                'balance' => 0,
                                'id' => '',
                                'inUse' => null,
                                'isSpecialCard' => null,
                                'name' => '',
                                'redemptionCode' => '',
                                'value' => 0
                ]
        ],
        'paymentSystems' => [
                [
                                'description' => '',
                                'groupName' => '',
                                'id' => 0,
                                'isCustom' => null,
                                'name' => '',
                                'requiresDocument' => null,
                                'selected' => null,
                                'stringId' => '',
                                'template' => '',
                                'validator' => [
                                                                'cardCodeMask' => '',
                                                                'cardCodeRegex' => '',
                                                                'mask' => '',
                                                                'regex' => '',
                                                                'weights' => [
                                                                                                                                
                                                                ]
                                ]
                ]
        ],
        'payments' => [
                [
                                'accountId' => '',
                                'bin' => '',
                                'installments' => 0,
                                'paymentSystem' => '',
                                'referenceValue' => 0,
                                'value' => 0
                ]
        ],
        'updateStatus' => ''
    ],
    'salesAssociateData' => [
        'salesAssociateId' => ''
    ],
    'shippingData' => [
        'address' => [
                'addressId' => '',
                'addressType' => '',
                'city' => '',
                'complement' => '',
                'country' => '',
                'geoCoordinates' => [
                                
                ],
                'neighborhood' => '',
                'number' => '',
                'postalCode' => '',
                'receiverName' => '',
                'reference' => '',
                'state' => '',
                'street' => ''
        ],
        'logisticsInfo' => [
                [
                                'deliveryWindow' => [
                                                                'endDateUtc' => '',
                                                                'lisPrice' => 0,
                                                                'price' => 0,
                                                                'startDateUtc' => '',
                                                                'tax' => 0
                                ],
                                'itemIndex' => 0,
                                'lockTTL' => '',
                                'price' => 0,
                                'selectedSla' => '',
                                'shippingEstimate' => ''
                ]
        ],
        'updateStatus' => ''
    ]
  ]),
  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/checkout/pub/orders', [
  'body' => '{
  "clientProfileData": {
    "corporateDocument": "",
    "corporateName": "",
    "corporatePhone": "",
    "document": "",
    "documentType": "",
    "email": "",
    "firstName": "",
    "isCorporate": false,
    "lastName": "",
    "phone": "",
    "stateInscription": "",
    "tradeName": ""
  },
  "items": [
    {
      "attachments": [],
      "bundleItems": [
        {
          "id": "",
          "name": "",
          "price": 0,
          "type": ""
        }
      ],
      "commission": 0,
      "freightCommission": 0,
      "id": "",
      "isGift": false,
      "itemAttachment": {
        "content": "",
        "name": ""
      },
      "measurementUnit": "",
      "price": 0,
      "priceTags": [
        {
          "identifier": "",
          "isPercentual": false,
          "name": "",
          "rawValue": 0,
          "value": 0
        }
      ],
      "quantity": 0,
      "seller": "",
      "unitMultiplier": 0
    }
  ],
  "marketingData": {
    "coupon": "",
    "utmCampaign": "",
    "utmMedium": "",
    "utmSource": "",
    "utmiCampaign": "",
    "utmiPage": "",
    "utmiPart": ""
  },
  "openTextField": "",
  "paymentData": {
    "giftCardMessages": [],
    "giftCards": [
      {
        "balance": 0,
        "id": "",
        "inUse": false,
        "isSpecialCard": false,
        "name": "",
        "redemptionCode": "",
        "value": 0
      }
    ],
    "paymentSystems": [
      {
        "description": "",
        "groupName": "",
        "id": 0,
        "isCustom": false,
        "name": "",
        "requiresDocument": false,
        "selected": false,
        "stringId": "",
        "template": "",
        "validator": {
          "cardCodeMask": "",
          "cardCodeRegex": "",
          "mask": "",
          "regex": "",
          "weights": []
        }
      }
    ],
    "payments": [
      {
        "accountId": "",
        "bin": "",
        "installments": 0,
        "paymentSystem": "",
        "referenceValue": 0,
        "value": 0
      }
    ],
    "updateStatus": ""
  },
  "salesAssociateData": {
    "salesAssociateId": ""
  },
  "shippingData": {
    "address": {
      "addressId": "",
      "addressType": "",
      "city": "",
      "complement": "",
      "country": "",
      "geoCoordinates": [],
      "neighborhood": "",
      "number": "",
      "postalCode": "",
      "receiverName": "",
      "reference": "",
      "state": "",
      "street": ""
    },
    "logisticsInfo": [
      {
        "deliveryWindow": {
          "endDateUtc": "",
          "lisPrice": 0,
          "price": 0,
          "startDateUtc": "",
          "tax": 0
        },
        "itemIndex": 0,
        "lockTTL": "",
        "price": 0,
        "selectedSla": "",
        "shippingEstimate": ""
      }
    ],
    "updateStatus": ""
  }
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orders');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clientProfileData' => [
    'corporateDocument' => '',
    'corporateName' => '',
    'corporatePhone' => '',
    'document' => '',
    'documentType' => '',
    'email' => '',
    'firstName' => '',
    'isCorporate' => null,
    'lastName' => '',
    'phone' => '',
    'stateInscription' => '',
    'tradeName' => ''
  ],
  'items' => [
    [
        'attachments' => [
                
        ],
        'bundleItems' => [
                [
                                'id' => '',
                                'name' => '',
                                'price' => 0,
                                'type' => ''
                ]
        ],
        'commission' => 0,
        'freightCommission' => 0,
        'id' => '',
        'isGift' => null,
        'itemAttachment' => [
                'content' => '',
                'name' => ''
        ],
        'measurementUnit' => '',
        'price' => 0,
        'priceTags' => [
                [
                                'identifier' => '',
                                'isPercentual' => null,
                                'name' => '',
                                'rawValue' => 0,
                                'value' => 0
                ]
        ],
        'quantity' => 0,
        'seller' => '',
        'unitMultiplier' => 0
    ]
  ],
  'marketingData' => [
    'coupon' => '',
    'utmCampaign' => '',
    'utmMedium' => '',
    'utmSource' => '',
    'utmiCampaign' => '',
    'utmiPage' => '',
    'utmiPart' => ''
  ],
  'openTextField' => '',
  'paymentData' => [
    'giftCardMessages' => [
        
    ],
    'giftCards' => [
        [
                'balance' => 0,
                'id' => '',
                'inUse' => null,
                'isSpecialCard' => null,
                'name' => '',
                'redemptionCode' => '',
                'value' => 0
        ]
    ],
    'paymentSystems' => [
        [
                'description' => '',
                'groupName' => '',
                'id' => 0,
                'isCustom' => null,
                'name' => '',
                'requiresDocument' => null,
                'selected' => null,
                'stringId' => '',
                'template' => '',
                'validator' => [
                                'cardCodeMask' => '',
                                'cardCodeRegex' => '',
                                'mask' => '',
                                'regex' => '',
                                'weights' => [
                                                                
                                ]
                ]
        ]
    ],
    'payments' => [
        [
                'accountId' => '',
                'bin' => '',
                'installments' => 0,
                'paymentSystem' => '',
                'referenceValue' => 0,
                'value' => 0
        ]
    ],
    'updateStatus' => ''
  ],
  'salesAssociateData' => [
    'salesAssociateId' => ''
  ],
  'shippingData' => [
    'address' => [
        'addressId' => '',
        'addressType' => '',
        'city' => '',
        'complement' => '',
        'country' => '',
        'geoCoordinates' => [
                
        ],
        'neighborhood' => '',
        'number' => '',
        'postalCode' => '',
        'receiverName' => '',
        'reference' => '',
        'state' => '',
        'street' => ''
    ],
    'logisticsInfo' => [
        [
                'deliveryWindow' => [
                                'endDateUtc' => '',
                                'lisPrice' => 0,
                                'price' => 0,
                                'startDateUtc' => '',
                                'tax' => 0
                ],
                'itemIndex' => 0,
                'lockTTL' => '',
                'price' => 0,
                'selectedSla' => '',
                'shippingEstimate' => ''
        ]
    ],
    'updateStatus' => ''
  ]
]));

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

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

append(json_encode([
  'clientProfileData' => [
    'corporateDocument' => '',
    'corporateName' => '',
    'corporatePhone' => '',
    'document' => '',
    'documentType' => '',
    'email' => '',
    'firstName' => '',
    'isCorporate' => null,
    'lastName' => '',
    'phone' => '',
    'stateInscription' => '',
    'tradeName' => ''
  ],
  'items' => [
    [
        'attachments' => [
                
        ],
        'bundleItems' => [
                [
                                'id' => '',
                                'name' => '',
                                'price' => 0,
                                'type' => ''
                ]
        ],
        'commission' => 0,
        'freightCommission' => 0,
        'id' => '',
        'isGift' => null,
        'itemAttachment' => [
                'content' => '',
                'name' => ''
        ],
        'measurementUnit' => '',
        'price' => 0,
        'priceTags' => [
                [
                                'identifier' => '',
                                'isPercentual' => null,
                                'name' => '',
                                'rawValue' => 0,
                                'value' => 0
                ]
        ],
        'quantity' => 0,
        'seller' => '',
        'unitMultiplier' => 0
    ]
  ],
  'marketingData' => [
    'coupon' => '',
    'utmCampaign' => '',
    'utmMedium' => '',
    'utmSource' => '',
    'utmiCampaign' => '',
    'utmiPage' => '',
    'utmiPart' => ''
  ],
  'openTextField' => '',
  'paymentData' => [
    'giftCardMessages' => [
        
    ],
    'giftCards' => [
        [
                'balance' => 0,
                'id' => '',
                'inUse' => null,
                'isSpecialCard' => null,
                'name' => '',
                'redemptionCode' => '',
                'value' => 0
        ]
    ],
    'paymentSystems' => [
        [
                'description' => '',
                'groupName' => '',
                'id' => 0,
                'isCustom' => null,
                'name' => '',
                'requiresDocument' => null,
                'selected' => null,
                'stringId' => '',
                'template' => '',
                'validator' => [
                                'cardCodeMask' => '',
                                'cardCodeRegex' => '',
                                'mask' => '',
                                'regex' => '',
                                'weights' => [
                                                                
                                ]
                ]
        ]
    ],
    'payments' => [
        [
                'accountId' => '',
                'bin' => '',
                'installments' => 0,
                'paymentSystem' => '',
                'referenceValue' => 0,
                'value' => 0
        ]
    ],
    'updateStatus' => ''
  ],
  'salesAssociateData' => [
    'salesAssociateId' => ''
  ],
  'shippingData' => [
    'address' => [
        'addressId' => '',
        'addressType' => '',
        'city' => '',
        'complement' => '',
        'country' => '',
        'geoCoordinates' => [
                
        ],
        'neighborhood' => '',
        'number' => '',
        'postalCode' => '',
        'receiverName' => '',
        'reference' => '',
        'state' => '',
        'street' => ''
    ],
    'logisticsInfo' => [
        [
                'deliveryWindow' => [
                                'endDateUtc' => '',
                                'lisPrice' => 0,
                                'price' => 0,
                                'startDateUtc' => '',
                                'tax' => 0
                ],
                'itemIndex' => 0,
                'lockTTL' => '',
                'price' => 0,
                'selectedSla' => '',
                'shippingEstimate' => ''
        ]
    ],
    'updateStatus' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/checkout/pub/orders');
$request->setRequestMethod('PUT');
$request->setBody($body);

$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/checkout/pub/orders' -Method PUT -Headers $headers -ContentType '' -Body '{
  "clientProfileData": {
    "corporateDocument": "",
    "corporateName": "",
    "corporatePhone": "",
    "document": "",
    "documentType": "",
    "email": "",
    "firstName": "",
    "isCorporate": false,
    "lastName": "",
    "phone": "",
    "stateInscription": "",
    "tradeName": ""
  },
  "items": [
    {
      "attachments": [],
      "bundleItems": [
        {
          "id": "",
          "name": "",
          "price": 0,
          "type": ""
        }
      ],
      "commission": 0,
      "freightCommission": 0,
      "id": "",
      "isGift": false,
      "itemAttachment": {
        "content": "",
        "name": ""
      },
      "measurementUnit": "",
      "price": 0,
      "priceTags": [
        {
          "identifier": "",
          "isPercentual": false,
          "name": "",
          "rawValue": 0,
          "value": 0
        }
      ],
      "quantity": 0,
      "seller": "",
      "unitMultiplier": 0
    }
  ],
  "marketingData": {
    "coupon": "",
    "utmCampaign": "",
    "utmMedium": "",
    "utmSource": "",
    "utmiCampaign": "",
    "utmiPage": "",
    "utmiPart": ""
  },
  "openTextField": "",
  "paymentData": {
    "giftCardMessages": [],
    "giftCards": [
      {
        "balance": 0,
        "id": "",
        "inUse": false,
        "isSpecialCard": false,
        "name": "",
        "redemptionCode": "",
        "value": 0
      }
    ],
    "paymentSystems": [
      {
        "description": "",
        "groupName": "",
        "id": 0,
        "isCustom": false,
        "name": "",
        "requiresDocument": false,
        "selected": false,
        "stringId": "",
        "template": "",
        "validator": {
          "cardCodeMask": "",
          "cardCodeRegex": "",
          "mask": "",
          "regex": "",
          "weights": []
        }
      }
    ],
    "payments": [
      {
        "accountId": "",
        "bin": "",
        "installments": 0,
        "paymentSystem": "",
        "referenceValue": 0,
        "value": 0
      }
    ],
    "updateStatus": ""
  },
  "salesAssociateData": {
    "salesAssociateId": ""
  },
  "shippingData": {
    "address": {
      "addressId": "",
      "addressType": "",
      "city": "",
      "complement": "",
      "country": "",
      "geoCoordinates": [],
      "neighborhood": "",
      "number": "",
      "postalCode": "",
      "receiverName": "",
      "reference": "",
      "state": "",
      "street": ""
    },
    "logisticsInfo": [
      {
        "deliveryWindow": {
          "endDateUtc": "",
          "lisPrice": 0,
          "price": 0,
          "startDateUtc": "",
          "tax": 0
        },
        "itemIndex": 0,
        "lockTTL": "",
        "price": 0,
        "selectedSla": "",
        "shippingEstimate": ""
      }
    ],
    "updateStatus": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orders' -Method PUT -Headers $headers -ContentType '' -Body '{
  "clientProfileData": {
    "corporateDocument": "",
    "corporateName": "",
    "corporatePhone": "",
    "document": "",
    "documentType": "",
    "email": "",
    "firstName": "",
    "isCorporate": false,
    "lastName": "",
    "phone": "",
    "stateInscription": "",
    "tradeName": ""
  },
  "items": [
    {
      "attachments": [],
      "bundleItems": [
        {
          "id": "",
          "name": "",
          "price": 0,
          "type": ""
        }
      ],
      "commission": 0,
      "freightCommission": 0,
      "id": "",
      "isGift": false,
      "itemAttachment": {
        "content": "",
        "name": ""
      },
      "measurementUnit": "",
      "price": 0,
      "priceTags": [
        {
          "identifier": "",
          "isPercentual": false,
          "name": "",
          "rawValue": 0,
          "value": 0
        }
      ],
      "quantity": 0,
      "seller": "",
      "unitMultiplier": 0
    }
  ],
  "marketingData": {
    "coupon": "",
    "utmCampaign": "",
    "utmMedium": "",
    "utmSource": "",
    "utmiCampaign": "",
    "utmiPage": "",
    "utmiPart": ""
  },
  "openTextField": "",
  "paymentData": {
    "giftCardMessages": [],
    "giftCards": [
      {
        "balance": 0,
        "id": "",
        "inUse": false,
        "isSpecialCard": false,
        "name": "",
        "redemptionCode": "",
        "value": 0
      }
    ],
    "paymentSystems": [
      {
        "description": "",
        "groupName": "",
        "id": 0,
        "isCustom": false,
        "name": "",
        "requiresDocument": false,
        "selected": false,
        "stringId": "",
        "template": "",
        "validator": {
          "cardCodeMask": "",
          "cardCodeRegex": "",
          "mask": "",
          "regex": "",
          "weights": []
        }
      }
    ],
    "payments": [
      {
        "accountId": "",
        "bin": "",
        "installments": 0,
        "paymentSystem": "",
        "referenceValue": 0,
        "value": 0
      }
    ],
    "updateStatus": ""
  },
  "salesAssociateData": {
    "salesAssociateId": ""
  },
  "shippingData": {
    "address": {
      "addressId": "",
      "addressType": "",
      "city": "",
      "complement": "",
      "country": "",
      "geoCoordinates": [],
      "neighborhood": "",
      "number": "",
      "postalCode": "",
      "receiverName": "",
      "reference": "",
      "state": "",
      "street": ""
    },
    "logisticsInfo": [
      {
        "deliveryWindow": {
          "endDateUtc": "",
          "lisPrice": 0,
          "price": 0,
          "startDateUtc": "",
          "tax": 0
        },
        "itemIndex": 0,
        "lockTTL": "",
        "price": 0,
        "selectedSla": "",
        "shippingEstimate": ""
      }
    ],
    "updateStatus": ""
  }
}'

import http.client

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

payload = "{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}"

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

conn.request("PUT", "/baseUrl/api/checkout/pub/orders", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orders"

payload = {
    "clientProfileData": {
        "corporateDocument": "",
        "corporateName": "",
        "corporatePhone": "",
        "document": "",
        "documentType": "",
        "email": "",
        "firstName": "",
        "isCorporate": False,
        "lastName": "",
        "phone": "",
        "stateInscription": "",
        "tradeName": ""
    },
    "items": [
        {
            "attachments": [],
            "bundleItems": [
                {
                    "id": "",
                    "name": "",
                    "price": 0,
                    "type": ""
                }
            ],
            "commission": 0,
            "freightCommission": 0,
            "id": "",
            "isGift": False,
            "itemAttachment": {
                "content": "",
                "name": ""
            },
            "measurementUnit": "",
            "price": 0,
            "priceTags": [
                {
                    "identifier": "",
                    "isPercentual": False,
                    "name": "",
                    "rawValue": 0,
                    "value": 0
                }
            ],
            "quantity": 0,
            "seller": "",
            "unitMultiplier": 0
        }
    ],
    "marketingData": {
        "coupon": "",
        "utmCampaign": "",
        "utmMedium": "",
        "utmSource": "",
        "utmiCampaign": "",
        "utmiPage": "",
        "utmiPart": ""
    },
    "openTextField": "",
    "paymentData": {
        "giftCardMessages": [],
        "giftCards": [
            {
                "balance": 0,
                "id": "",
                "inUse": False,
                "isSpecialCard": False,
                "name": "",
                "redemptionCode": "",
                "value": 0
            }
        ],
        "paymentSystems": [
            {
                "description": "",
                "groupName": "",
                "id": 0,
                "isCustom": False,
                "name": "",
                "requiresDocument": False,
                "selected": False,
                "stringId": "",
                "template": "",
                "validator": {
                    "cardCodeMask": "",
                    "cardCodeRegex": "",
                    "mask": "",
                    "regex": "",
                    "weights": []
                }
            }
        ],
        "payments": [
            {
                "accountId": "",
                "bin": "",
                "installments": 0,
                "paymentSystem": "",
                "referenceValue": 0,
                "value": 0
            }
        ],
        "updateStatus": ""
    },
    "salesAssociateData": { "salesAssociateId": "" },
    "shippingData": {
        "address": {
            "addressId": "",
            "addressType": "",
            "city": "",
            "complement": "",
            "country": "",
            "geoCoordinates": [],
            "neighborhood": "",
            "number": "",
            "postalCode": "",
            "receiverName": "",
            "reference": "",
            "state": "",
            "street": ""
        },
        "logisticsInfo": [
            {
                "deliveryWindow": {
                    "endDateUtc": "",
                    "lisPrice": 0,
                    "price": 0,
                    "startDateUtc": "",
                    "tax": 0
                },
                "itemIndex": 0,
                "lockTTL": "",
                "price": 0,
                "selectedSla": "",
                "shippingEstimate": ""
            }
        ],
        "updateStatus": ""
    }
}
headers = {
    "content-type": "",
    "accept": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orders"

payload <- "{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orders")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = ''
request["accept"] = ''
request.body = "{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/api/checkout/pub/orders') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"clientProfileData\": {\n    \"corporateDocument\": \"\",\n    \"corporateName\": \"\",\n    \"corporatePhone\": \"\",\n    \"document\": \"\",\n    \"documentType\": \"\",\n    \"email\": \"\",\n    \"firstName\": \"\",\n    \"isCorporate\": false,\n    \"lastName\": \"\",\n    \"phone\": \"\",\n    \"stateInscription\": \"\",\n    \"tradeName\": \"\"\n  },\n  \"items\": [\n    {\n      \"attachments\": [],\n      \"bundleItems\": [\n        {\n          \"id\": \"\",\n          \"name\": \"\",\n          \"price\": 0,\n          \"type\": \"\"\n        }\n      ],\n      \"commission\": 0,\n      \"freightCommission\": 0,\n      \"id\": \"\",\n      \"isGift\": false,\n      \"itemAttachment\": {\n        \"content\": \"\",\n        \"name\": \"\"\n      },\n      \"measurementUnit\": \"\",\n      \"price\": 0,\n      \"priceTags\": [\n        {\n          \"identifier\": \"\",\n          \"isPercentual\": false,\n          \"name\": \"\",\n          \"rawValue\": 0,\n          \"value\": 0\n        }\n      ],\n      \"quantity\": 0,\n      \"seller\": \"\",\n      \"unitMultiplier\": 0\n    }\n  ],\n  \"marketingData\": {\n    \"coupon\": \"\",\n    \"utmCampaign\": \"\",\n    \"utmMedium\": \"\",\n    \"utmSource\": \"\",\n    \"utmiCampaign\": \"\",\n    \"utmiPage\": \"\",\n    \"utmiPart\": \"\"\n  },\n  \"openTextField\": \"\",\n  \"paymentData\": {\n    \"giftCardMessages\": [],\n    \"giftCards\": [\n      {\n        \"balance\": 0,\n        \"id\": \"\",\n        \"inUse\": false,\n        \"isSpecialCard\": false,\n        \"name\": \"\",\n        \"redemptionCode\": \"\",\n        \"value\": 0\n      }\n    ],\n    \"paymentSystems\": [\n      {\n        \"description\": \"\",\n        \"groupName\": \"\",\n        \"id\": 0,\n        \"isCustom\": false,\n        \"name\": \"\",\n        \"requiresDocument\": false,\n        \"selected\": false,\n        \"stringId\": \"\",\n        \"template\": \"\",\n        \"validator\": {\n          \"cardCodeMask\": \"\",\n          \"cardCodeRegex\": \"\",\n          \"mask\": \"\",\n          \"regex\": \"\",\n          \"weights\": []\n        }\n      }\n    ],\n    \"payments\": [\n      {\n        \"accountId\": \"\",\n        \"bin\": \"\",\n        \"installments\": 0,\n        \"paymentSystem\": \"\",\n        \"referenceValue\": 0,\n        \"value\": 0\n      }\n    ],\n    \"updateStatus\": \"\"\n  },\n  \"salesAssociateData\": {\n    \"salesAssociateId\": \"\"\n  },\n  \"shippingData\": {\n    \"address\": {\n      \"addressId\": \"\",\n      \"addressType\": \"\",\n      \"city\": \"\",\n      \"complement\": \"\",\n      \"country\": \"\",\n      \"geoCoordinates\": [],\n      \"neighborhood\": \"\",\n      \"number\": \"\",\n      \"postalCode\": \"\",\n      \"receiverName\": \"\",\n      \"reference\": \"\",\n      \"state\": \"\",\n      \"street\": \"\"\n    },\n    \"logisticsInfo\": [\n      {\n        \"deliveryWindow\": {\n          \"endDateUtc\": \"\",\n          \"lisPrice\": 0,\n          \"price\": 0,\n          \"startDateUtc\": \"\",\n          \"tax\": 0\n        },\n        \"itemIndex\": 0,\n        \"lockTTL\": \"\",\n        \"price\": 0,\n        \"selectedSla\": \"\",\n        \"shippingEstimate\": \"\"\n      }\n    ],\n    \"updateStatus\": \"\"\n  }\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "clientProfileData": json!({
            "corporateDocument": "",
            "corporateName": "",
            "corporatePhone": "",
            "document": "",
            "documentType": "",
            "email": "",
            "firstName": "",
            "isCorporate": false,
            "lastName": "",
            "phone": "",
            "stateInscription": "",
            "tradeName": ""
        }),
        "items": (
            json!({
                "attachments": (),
                "bundleItems": (
                    json!({
                        "id": "",
                        "name": "",
                        "price": 0,
                        "type": ""
                    })
                ),
                "commission": 0,
                "freightCommission": 0,
                "id": "",
                "isGift": false,
                "itemAttachment": json!({
                    "content": "",
                    "name": ""
                }),
                "measurementUnit": "",
                "price": 0,
                "priceTags": (
                    json!({
                        "identifier": "",
                        "isPercentual": false,
                        "name": "",
                        "rawValue": 0,
                        "value": 0
                    })
                ),
                "quantity": 0,
                "seller": "",
                "unitMultiplier": 0
            })
        ),
        "marketingData": json!({
            "coupon": "",
            "utmCampaign": "",
            "utmMedium": "",
            "utmSource": "",
            "utmiCampaign": "",
            "utmiPage": "",
            "utmiPart": ""
        }),
        "openTextField": "",
        "paymentData": json!({
            "giftCardMessages": (),
            "giftCards": (
                json!({
                    "balance": 0,
                    "id": "",
                    "inUse": false,
                    "isSpecialCard": false,
                    "name": "",
                    "redemptionCode": "",
                    "value": 0
                })
            ),
            "paymentSystems": (
                json!({
                    "description": "",
                    "groupName": "",
                    "id": 0,
                    "isCustom": false,
                    "name": "",
                    "requiresDocument": false,
                    "selected": false,
                    "stringId": "",
                    "template": "",
                    "validator": json!({
                        "cardCodeMask": "",
                        "cardCodeRegex": "",
                        "mask": "",
                        "regex": "",
                        "weights": ()
                    })
                })
            ),
            "payments": (
                json!({
                    "accountId": "",
                    "bin": "",
                    "installments": 0,
                    "paymentSystem": "",
                    "referenceValue": 0,
                    "value": 0
                })
            ),
            "updateStatus": ""
        }),
        "salesAssociateData": json!({"salesAssociateId": ""}),
        "shippingData": json!({
            "address": json!({
                "addressId": "",
                "addressType": "",
                "city": "",
                "complement": "",
                "country": "",
                "geoCoordinates": (),
                "neighborhood": "",
                "number": "",
                "postalCode": "",
                "receiverName": "",
                "reference": "",
                "state": "",
                "street": ""
            }),
            "logisticsInfo": (
                json!({
                    "deliveryWindow": json!({
                        "endDateUtc": "",
                        "lisPrice": 0,
                        "price": 0,
                        "startDateUtc": "",
                        "tax": 0
                    }),
                    "itemIndex": 0,
                    "lockTTL": "",
                    "price": 0,
                    "selectedSla": "",
                    "shippingEstimate": ""
                })
            ),
            "updateStatus": ""
        })
    });

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/api/checkout/pub/orders \
  --header 'accept: ' \
  --header 'content-type: ' \
  --data '{
  "clientProfileData": {
    "corporateDocument": "",
    "corporateName": "",
    "corporatePhone": "",
    "document": "",
    "documentType": "",
    "email": "",
    "firstName": "",
    "isCorporate": false,
    "lastName": "",
    "phone": "",
    "stateInscription": "",
    "tradeName": ""
  },
  "items": [
    {
      "attachments": [],
      "bundleItems": [
        {
          "id": "",
          "name": "",
          "price": 0,
          "type": ""
        }
      ],
      "commission": 0,
      "freightCommission": 0,
      "id": "",
      "isGift": false,
      "itemAttachment": {
        "content": "",
        "name": ""
      },
      "measurementUnit": "",
      "price": 0,
      "priceTags": [
        {
          "identifier": "",
          "isPercentual": false,
          "name": "",
          "rawValue": 0,
          "value": 0
        }
      ],
      "quantity": 0,
      "seller": "",
      "unitMultiplier": 0
    }
  ],
  "marketingData": {
    "coupon": "",
    "utmCampaign": "",
    "utmMedium": "",
    "utmSource": "",
    "utmiCampaign": "",
    "utmiPage": "",
    "utmiPart": ""
  },
  "openTextField": "",
  "paymentData": {
    "giftCardMessages": [],
    "giftCards": [
      {
        "balance": 0,
        "id": "",
        "inUse": false,
        "isSpecialCard": false,
        "name": "",
        "redemptionCode": "",
        "value": 0
      }
    ],
    "paymentSystems": [
      {
        "description": "",
        "groupName": "",
        "id": 0,
        "isCustom": false,
        "name": "",
        "requiresDocument": false,
        "selected": false,
        "stringId": "",
        "template": "",
        "validator": {
          "cardCodeMask": "",
          "cardCodeRegex": "",
          "mask": "",
          "regex": "",
          "weights": []
        }
      }
    ],
    "payments": [
      {
        "accountId": "",
        "bin": "",
        "installments": 0,
        "paymentSystem": "",
        "referenceValue": 0,
        "value": 0
      }
    ],
    "updateStatus": ""
  },
  "salesAssociateData": {
    "salesAssociateId": ""
  },
  "shippingData": {
    "address": {
      "addressId": "",
      "addressType": "",
      "city": "",
      "complement": "",
      "country": "",
      "geoCoordinates": [],
      "neighborhood": "",
      "number": "",
      "postalCode": "",
      "receiverName": "",
      "reference": "",
      "state": "",
      "street": ""
    },
    "logisticsInfo": [
      {
        "deliveryWindow": {
          "endDateUtc": "",
          "lisPrice": 0,
          "price": 0,
          "startDateUtc": "",
          "tax": 0
        },
        "itemIndex": 0,
        "lockTTL": "",
        "price": 0,
        "selectedSla": "",
        "shippingEstimate": ""
      }
    ],
    "updateStatus": ""
  }
}'

echo '{
  "clientProfileData": {
    "corporateDocument": "",
    "corporateName": "",
    "corporatePhone": "",
    "document": "",
    "documentType": "",
    "email": "",
    "firstName": "",
    "isCorporate": false,
    "lastName": "",
    "phone": "",
    "stateInscription": "",
    "tradeName": ""
  },
  "items": [
    {
      "attachments": [],
      "bundleItems": [
        {
          "id": "",
          "name": "",
          "price": 0,
          "type": ""
        }
      ],
      "commission": 0,
      "freightCommission": 0,
      "id": "",
      "isGift": false,
      "itemAttachment": {
        "content": "",
        "name": ""
      },
      "measurementUnit": "",
      "price": 0,
      "priceTags": [
        {
          "identifier": "",
          "isPercentual": false,
          "name": "",
          "rawValue": 0,
          "value": 0
        }
      ],
      "quantity": 0,
      "seller": "",
      "unitMultiplier": 0
    }
  ],
  "marketingData": {
    "coupon": "",
    "utmCampaign": "",
    "utmMedium": "",
    "utmSource": "",
    "utmiCampaign": "",
    "utmiPage": "",
    "utmiPart": ""
  },
  "openTextField": "",
  "paymentData": {
    "giftCardMessages": [],
    "giftCards": [
      {
        "balance": 0,
        "id": "",
        "inUse": false,
        "isSpecialCard": false,
        "name": "",
        "redemptionCode": "",
        "value": 0
      }
    ],
    "paymentSystems": [
      {
        "description": "",
        "groupName": "",
        "id": 0,
        "isCustom": false,
        "name": "",
        "requiresDocument": false,
        "selected": false,
        "stringId": "",
        "template": "",
        "validator": {
          "cardCodeMask": "",
          "cardCodeRegex": "",
          "mask": "",
          "regex": "",
          "weights": []
        }
      }
    ],
    "payments": [
      {
        "accountId": "",
        "bin": "",
        "installments": 0,
        "paymentSystem": "",
        "referenceValue": 0,
        "value": 0
      }
    ],
    "updateStatus": ""
  },
  "salesAssociateData": {
    "salesAssociateId": ""
  },
  "shippingData": {
    "address": {
      "addressId": "",
      "addressType": "",
      "city": "",
      "complement": "",
      "country": "",
      "geoCoordinates": [],
      "neighborhood": "",
      "number": "",
      "postalCode": "",
      "receiverName": "",
      "reference": "",
      "state": "",
      "street": ""
    },
    "logisticsInfo": [
      {
        "deliveryWindow": {
          "endDateUtc": "",
          "lisPrice": 0,
          "price": 0,
          "startDateUtc": "",
          "tax": 0
        },
        "itemIndex": 0,
        "lockTTL": "",
        "price": 0,
        "selectedSla": "",
        "shippingEstimate": ""
      }
    ],
    "updateStatus": ""
  }
}' |  \
  http PUT {{baseUrl}}/api/checkout/pub/orders \
  accept:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'content-type: ' \
  --header 'accept: ' \
  --body-data '{\n  "clientProfileData": {\n    "corporateDocument": "",\n    "corporateName": "",\n    "corporatePhone": "",\n    "document": "",\n    "documentType": "",\n    "email": "",\n    "firstName": "",\n    "isCorporate": false,\n    "lastName": "",\n    "phone": "",\n    "stateInscription": "",\n    "tradeName": ""\n  },\n  "items": [\n    {\n      "attachments": [],\n      "bundleItems": [\n        {\n          "id": "",\n          "name": "",\n          "price": 0,\n          "type": ""\n        }\n      ],\n      "commission": 0,\n      "freightCommission": 0,\n      "id": "",\n      "isGift": false,\n      "itemAttachment": {\n        "content": "",\n        "name": ""\n      },\n      "measurementUnit": "",\n      "price": 0,\n      "priceTags": [\n        {\n          "identifier": "",\n          "isPercentual": false,\n          "name": "",\n          "rawValue": 0,\n          "value": 0\n        }\n      ],\n      "quantity": 0,\n      "seller": "",\n      "unitMultiplier": 0\n    }\n  ],\n  "marketingData": {\n    "coupon": "",\n    "utmCampaign": "",\n    "utmMedium": "",\n    "utmSource": "",\n    "utmiCampaign": "",\n    "utmiPage": "",\n    "utmiPart": ""\n  },\n  "openTextField": "",\n  "paymentData": {\n    "giftCardMessages": [],\n    "giftCards": [\n      {\n        "balance": 0,\n        "id": "",\n        "inUse": false,\n        "isSpecialCard": false,\n        "name": "",\n        "redemptionCode": "",\n        "value": 0\n      }\n    ],\n    "paymentSystems": [\n      {\n        "description": "",\n        "groupName": "",\n        "id": 0,\n        "isCustom": false,\n        "name": "",\n        "requiresDocument": false,\n        "selected": false,\n        "stringId": "",\n        "template": "",\n        "validator": {\n          "cardCodeMask": "",\n          "cardCodeRegex": "",\n          "mask": "",\n          "regex": "",\n          "weights": []\n        }\n      }\n    ],\n    "payments": [\n      {\n        "accountId": "",\n        "bin": "",\n        "installments": 0,\n        "paymentSystem": "",\n        "referenceValue": 0,\n        "value": 0\n      }\n    ],\n    "updateStatus": ""\n  },\n  "salesAssociateData": {\n    "salesAssociateId": ""\n  },\n  "shippingData": {\n    "address": {\n      "addressId": "",\n      "addressType": "",\n      "city": "",\n      "complement": "",\n      "country": "",\n      "geoCoordinates": [],\n      "neighborhood": "",\n      "number": "",\n      "postalCode": "",\n      "receiverName": "",\n      "reference": "",\n      "state": "",\n      "street": ""\n    },\n    "logisticsInfo": [\n      {\n        "deliveryWindow": {\n          "endDateUtc": "",\n          "lisPrice": 0,\n          "price": 0,\n          "startDateUtc": "",\n          "tax": 0\n        },\n        "itemIndex": 0,\n        "lockTTL": "",\n        "price": 0,\n        "selectedSla": "",\n        "shippingEstimate": ""\n      }\n    ],\n    "updateStatus": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orders

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]
let parameters = [
  "clientProfileData": [
    "corporateDocument": "",
    "corporateName": "",
    "corporatePhone": "",
    "document": "",
    "documentType": "",
    "email": "",
    "firstName": "",
    "isCorporate": false,
    "lastName": "",
    "phone": "",
    "stateInscription": "",
    "tradeName": ""
  ],
  "items": [
    [
      "attachments": [],
      "bundleItems": [
        [
          "id": "",
          "name": "",
          "price": 0,
          "type": ""
        ]
      ],
      "commission": 0,
      "freightCommission": 0,
      "id": "",
      "isGift": false,
      "itemAttachment": [
        "content": "",
        "name": ""
      ],
      "measurementUnit": "",
      "price": 0,
      "priceTags": [
        [
          "identifier": "",
          "isPercentual": false,
          "name": "",
          "rawValue": 0,
          "value": 0
        ]
      ],
      "quantity": 0,
      "seller": "",
      "unitMultiplier": 0
    ]
  ],
  "marketingData": [
    "coupon": "",
    "utmCampaign": "",
    "utmMedium": "",
    "utmSource": "",
    "utmiCampaign": "",
    "utmiPage": "",
    "utmiPart": ""
  ],
  "openTextField": "",
  "paymentData": [
    "giftCardMessages": [],
    "giftCards": [
      [
        "balance": 0,
        "id": "",
        "inUse": false,
        "isSpecialCard": false,
        "name": "",
        "redemptionCode": "",
        "value": 0
      ]
    ],
    "paymentSystems": [
      [
        "description": "",
        "groupName": "",
        "id": 0,
        "isCustom": false,
        "name": "",
        "requiresDocument": false,
        "selected": false,
        "stringId": "",
        "template": "",
        "validator": [
          "cardCodeMask": "",
          "cardCodeRegex": "",
          "mask": "",
          "regex": "",
          "weights": []
        ]
      ]
    ],
    "payments": [
      [
        "accountId": "",
        "bin": "",
        "installments": 0,
        "paymentSystem": "",
        "referenceValue": 0,
        "value": 0
      ]
    ],
    "updateStatus": ""
  ],
  "salesAssociateData": ["salesAssociateId": ""],
  "shippingData": [
    "address": [
      "addressId": "",
      "addressType": "",
      "city": "",
      "complement": "",
      "country": "",
      "geoCoordinates": [],
      "neighborhood": "",
      "number": "",
      "postalCode": "",
      "receiverName": "",
      "reference": "",
      "state": "",
      "street": ""
    ],
    "logisticsInfo": [
      [
        "deliveryWindow": [
          "endDateUtc": "",
          "lisPrice": 0,
          "price": 0,
          "startDateUtc": "",
          "tax": 0
        ],
        "itemIndex": 0,
        "lockTTL": "",
        "price": 0,
        "selectedSla": "",
        "shippingEstimate": ""
      ]
    ],
    "updateStatus": ""
  ]
] as [String : Any]

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

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "orderForm": null,
  "orders": [
    {
      "allowCancellation": false,
      "allowChangeSeller": false,
      "allowEdition": false,
      "changeData": null,
      "checkedInPickupPointId": null,
      "clientPreferencesData": null,
      "clientProfileData": {
        "corporateDocument": null,
        "corporateName": null,
        "corporatePhone": null,
        "customerClass": null,
        "document": "12345678900",
        "documentType": "cpf",
        "email": "clark.kent@example.com",
        "firstName": "Clark",
        "isCorporate": false,
        "lastName": "Kent",
        "phone": "+5521998765432",
        "profileCompleteOnLoading": false,
        "profileErrorOnLoading": null,
        "stateInscription": null,
        "tradeName": null
      },
      "commercialConditionData": null,
      "creationDate": "2021-07-13T18:33:25.3029443Z",
      "customData": null,
      "followUpEmail": "6c10d76b5170456d89823b38b7c8f6ac@ct.vtex.com.br",
      "giftRegistryData": null,
      "hooksData": null,
      "hostName": "mystore",
      "invoiceData": null,
      "isCheckedIn": false,
      "isCompleted": false,
      "isUserDataVisible": true,
      "itemMetadata": {
        "items": [
          {
            "assemblyOptions": [],
            "detailUrl": "/chopp-brahma-claro-30l/p",
            "ean": null,
            "id": "2",
            "imageUrl": "http://mystore.vteximg.com.br/arquivos/ids/155400-55-55/30l_v2.png?v=637303412106100000",
            "name": "Chopp Brahma Claro 30L",
            "productId": "2",
            "refId": "CBC30L",
            "seller": "1",
            "skuName": "Chopp Brahma Claro 30L"
          }
        ]
      },
      "items": [
        {
          "additionalInfo": {
            "brandId": "2000000",
            "brandName": "Brahma",
            "dimension": null,
            "offeringInfo": null,
            "offeringType": null,
            "offeringTypeId": null
          },
          "assemblies": [],
          "attachmentOfferings": [],
          "attachments": [],
          "availability": "available",
          "bundleItems": [],
          "components": [],
          "detailUrl": "/chopp-brahma-claro-30l/p",
          "ean": null,
          "id": "2",
          "imageUrl": "http://mystore.vteximg.com.br/arquivos/ids/155400-55-55/30l_v2.png?v=637303412106100000",
          "isGift": false,
          "listPrice": 49900,
          "manualPrice": null,
          "manualPriceAppliedBy": null,
          "manufacturerCode": null,
          "measurementUnit": "un",
          "modalType": null,
          "name": "Chopp Brahma Claro 30L",
          "offerings": [],
          "parentAssemblyBinding": null,
          "parentItemIndex": null,
          "preSaleDate": null,
          "price": 32890,
          "priceDefinition": {
            "calculatedSellingPrice": 32890,
            "sellingPrices": [
              {
                "quantity": 1,
                "value": 32890
              }
            ],
            "total": 32890
          },
          "priceTags": [],
          "priceValidUntil": "2022-07-13T18:30:46Z",
          "productCategories": {
            "1": "Bebidas"
          },
          "productCategoryIds": "/1/",
          "productId": "2",
          "productRefId": "",
          "quantity": 1,
          "refId": "CBC30L",
          "rewardValue": 0,
          "seller": "1",
          "sellerChain": [
            "1"
          ],
          "sellingPrice": 32890,
          "skuName": "Chopp Brahma Claro 30L",
          "tax": 0,
          "uniqueId": "9D6E447B3FF64CEDA33B17C01379C119",
          "unitMultiplier": 1
        }
      ],
      "lastChange": "2021-07-13T18:33:27.736557Z",
      "marketingData": null,
      "merchantName": null,
      "openTextField": {
        "value": null
      },
      "orderFormCreationDate": "2021-07-13T18:33:25.1313373Z",
      "orderGroup": "1146512005522",
      "orderId": "1146512005522-01",
      "paymentData": {
        "giftCards": [],
        "transactions": [
          {
            "isActive": true,
            "merchantName": "MYSTORE",
            "payments": [],
            "sharedTransaction": false,
            "transactionId": "296D6D245C17437E823EB77E403FC88D"
          }
        ]
      },
      "ratesAndBenefitsData": {
        "rateAndBenefitsIdentifiers": [],
        "teaser": []
      },
      "roundingError": 0,
      "salesChannel": "1",
      "sellerOrderId": "00-1146512005522-01",
      "sellers": [
        {
          "id": "1",
          "logo": "",
          "name": "Tracking QA"
        }
      ],
      "shippingData": {
        "address": {
          "addressId": "teste",
          "addressType": "residential",
          "city": "Brasília",
          "complement": "15º andar",
          "country": "BRA",
          "geoCoordinates": [
            -47.924747467041016,
            -15.832582473754883
          ],
          "isDisposable": true,
          "neighborhood": "Copacabana",
          "number": "123",
          "postalCode": "70386000",
          "receiverName": "Clark Kent",
          "reference": null,
          "state": "DF",
          "street": "Rua da minha casa"
        },
        "availableAddresses": [
          {
            "addressId": "teste",
            "addressType": "residential",
            "city": "Rio de Janeiro",
            "complement": "15º andar",
            "country": "BRA",
            "geoCoordinates": [
              -47.924747467041016,
              -15.832582473754883
            ],
            "isDisposable": true,
            "neighborhood": "Copacabana",
            "number": "123",
            "postalCode": "12345000",
            "receiverName": "Clark Kent",
            "reference": null,
            "state": "RJ",
            "street": "Rua da minha casa"
          }
        ],
        "logisticsInfo": [
          {
            "addressId": "teste",
            "deliveryChannels": [
              {
                "id": "delivery"
              },
              {
                "id": "pickup-in-point"
              }
            ],
            "itemId": "2",
            "itemIndex": 0,
            "selectedDeliveryChannel": "delivery",
            "selectedSla": "Normal",
            "shipsTo": [
              "BRA",
              "COL",
              "USA"
            ],
            "slas": [
              {
                "availableDeliveryWindows": [],
                "deliveryChannel": "delivery",
                "deliveryIds": [
                  {
                    "courierId": "1",
                    "courierName": "Transportadora",
                    "dockId": "1",
                    "kitItemDetails": [],
                    "quantity": 1,
                    "warehouseId": "1_1"
                  }
                ],
                "deliveryWindow": null,
                "id": "Normal",
                "listPrice": 1500,
                "lockTTL": "10d",
                "name": "Normal",
                "pickupDistance": 0,
                "pickupPointId": null,
                "pickupStoreInfo": {
                  "additionalInfo": null,
                  "address": null,
                  "dockId": null,
                  "friendlyName": null,
                  "isPickupStore": false
                },
                "polygonName": null,
                "price": 1500,
                "shippingEstimate": "3bd",
                "shippingEstimateDate": null,
                "tax": 0,
                "transitTime": "3bd"
              }
            ]
          }
        ],
        "pickupPoints": [],
        "selectedAddresses": [
          {
            "addressId": "teste",
            "addressType": "residential",
            "city": "Rio de Janeiro",
            "complement": "15º andar",
            "country": "BRA",
            "geoCoordinates": [
              -47.924747467041016,
              -15.832582473754883
            ],
            "isDisposable": true,
            "neighborhood": "Copacabana",
            "number": "123",
            "postalCode": "12345000",
            "receiverName": "Clark Kent",
            "reference": null,
            "state": "RJ",
            "street": "Rua da minha casa"
          }
        ]
      },
      "state": null,
      "storeId": null,
      "storePreferencesData": {
        "countryCode": "BRA",
        "currencyCode": "BRL",
        "currencyFormatInfo": {
          "currencyDecimalDigits": 2,
          "currencyDecimalSeparator": ",",
          "currencyGroupSeparator": ".",
          "currencyGroupSize": 3,
          "startsWithCurrencySymbol": true
        },
        "currencyLocale": 1046,
        "currencySymbol": "R$",
        "saveUserData": false,
        "timeZone": "E. South America Standard Time"
      },
      "subscriptionData": null,
      "taxData": null,
      "timeZoneCreationDate": "2021-07-13T15:33:25.3029443",
      "timeZoneLastChange": "2021-07-13T15:33:27.736557",
      "totals": [
        {
          "id": "Items",
          "name": "Total dos Itens",
          "value": 32890
        },
        {
          "id": "Discounts",
          "name": "Total dos Descontos",
          "value": 0
        },
        {
          "id": "Shipping",
          "name": "Total do Frete",
          "value": 1500
        },
        {
          "id": "Tax",
          "name": "Total da Taxa",
          "value": 0
        }
      ],
      "userType": "",
      "value": 34390
    }
  ],
  "salesAssociateData": {
    "salesAssociateId": "seller123"
  },
  "transactionData": {
    "gatewayCallbackTemplatePath": "/checkout/gatewayCallback/1146512005522/{messageCode}",
    "merchantTransactions": [
      {
        "id": "MYSTORE",
        "merchantName": "MYSTORE",
        "payments": [
          {
            "accountId": null,
            "bin": null,
            "giftCardId": null,
            "giftCardProvider": null,
            "giftCardRedemptionCode": null,
            "paymentSystem": "6",
            "referenceValue": 34390,
            "tokenId": null,
            "value": 34390
          }
        ],
        "transactionId": "296D6D245C17437E823EB77E403FC88D"
      }
    ],
    "receiverUri": "https://mystore.vtexpayments.com.br/split/1146512005522/payments"
  }
}

POST Process order

{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup

HEADERS

Content-Type

QUERY PARAMS

orderGroup

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup" {:headers {:content-type ""
                                                                                                   :accept ""
                                                                                                   :cookie ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
  "cookie" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup"),
    Headers =
    {
        { "accept", "" },
        { "cookie", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
request.AddHeader("cookie", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup"

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

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

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

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

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

}

POST /baseUrl/api/checkout/pub/gatewayCallback/:orderGroup HTTP/1.1
Content-Type: 
Accept: 
Cookie: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .setHeader("cookie", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup"))
    .header("content-type", "")
    .header("accept", "")
    .header("cookie", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .addHeader("cookie", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup")
  .header("content-type", "")
  .header("accept", "")
  .header("cookie", "")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('cookie', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup',
  headers: {'content-type': '', accept: '', cookie: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup';
const options = {method: 'POST', headers: {'content-type': '', accept: '', cookie: ''}};

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/checkout/pub/gatewayCallback/:orderGroup',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: '',
    cookie: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .addHeader("cookie", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/gatewayCallback/:orderGroup',
  headers: {
    'content-type': '',
    accept: '',
    cookie: ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup',
  headers: {'content-type': '', accept: '', cookie: ''}
};

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/checkout/pub/gatewayCallback/:orderGroup');

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

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/checkout/pub/gatewayCallback/:orderGroup',
  headers: {'content-type': '', accept: '', cookie: ''}
};

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

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

const url = '{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup';
const options = {method: 'POST', headers: {'content-type': '', accept: '', cookie: ''}};

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": @"",
                           @"cookie": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/gatewayCallback/:orderGroup" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
  ("cookie", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: ",
    "cookie: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
    'cookie' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => '',
  'accept' => '',
  'cookie' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$headers.Add("cookie", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$headers.Add("cookie", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/gatewayCallback/:orderGroup", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/api/checkout/pub/gatewayCallback/:orderGroup') do |req|
  req.headers['accept'] = ''
  req.headers['cookie'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup \
  --header 'accept: ' \
  --header 'content-type: ' \
  --header 'cookie: '

http POST {{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup \
  accept:'' \
  content-type:'' \
  cookie:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --header 'cookie: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/gatewayCallback/:orderGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

GET Get sellers by region or address

{{baseUrl}}/api/checkout/pub/regions/:regionId

HEADERS

Content-Type

QUERY PARAMS

country

regionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/regions/:regionId?country=");

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/checkout/pub/regions/:regionId" {:headers {:content-type ""
                                                                                        :accept ""}
                                                                              :query-params {:country ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/regions/:regionId?country="
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/checkout/pub/regions/:regionId?country="),
    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/checkout/pub/regions/:regionId?country=");
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/checkout/pub/regions/:regionId?country="

	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/checkout/pub/regions/:regionId?country= HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/checkout/pub/regions/:regionId?country=")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/regions/:regionId?country="))
    .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/checkout/pub/regions/:regionId?country=")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pub/regions/:regionId?country=")
  .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/checkout/pub/regions/:regionId?country=');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pub/regions/:regionId',
  params: {country: ''},
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/regions/:regionId?country=';
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/checkout/pub/regions/:regionId?country=',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/regions/:regionId?country=")
  .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/checkout/pub/regions/:regionId?country=',
  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/checkout/pub/regions/:regionId',
  qs: {country: ''},
  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/checkout/pub/regions/:regionId');

req.query({
  country: ''
});

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/checkout/pub/regions/:regionId',
  params: {country: ''},
  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/checkout/pub/regions/:regionId?country=';
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/checkout/pub/regions/:regionId?country="]
                                                       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/checkout/pub/regions/:regionId?country=" 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/checkout/pub/regions/:regionId?country=",
  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/checkout/pub/regions/:regionId?country=', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/regions/:regionId');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'country' => ''
]);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/regions/:regionId');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'country' => ''
]));

$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/checkout/pub/regions/:regionId?country=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/regions/:regionId?country=' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/api/checkout/pub/regions/:regionId?country=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/regions/:regionId"

querystring = {"country":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/regions/:regionId"

queryString <- list(country = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/regions/:regionId?country=")

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/checkout/pub/regions/:regionId') do |req|
  req.headers['accept'] = ''
  req.params['country'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("country", ""),
    ];

    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)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/checkout/pub/regions/:regionId?country=' \
  --header 'accept: ' \
  --header 'content-type: '

http GET '{{baseUrl}}/api/checkout/pub/regions/:regionId?country=' \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/api/checkout/pub/regions/:regionId?country='

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/regions/:regionId?country=")! 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()

POST Add cart items

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items" {:headers {:content-type ""
                                                                                                    :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items"),
    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/checkout/pub/orderForm/:orderFormId/items");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/items HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/items',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/items',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items',
  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/checkout/pub/orderForm/:orderFormId/items';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/items"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/items" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/items', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/items' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/items", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/items') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

POST Add coupons to the cart

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons" {:headers {:content-type ""
                                                                                                      :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons"),
    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/checkout/pub/orderForm/:orderFormId/coupons");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/coupons HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/coupons',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/coupons',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons',
  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/checkout/pub/orderForm/:orderFormId/coupons';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/coupons"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/coupons" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/coupons', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/coupons' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/coupons", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/coupons') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/coupons")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

GET Cart installments

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments

HEADERS

Content-Type

QUERY PARAMS

paymentSystem

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=");

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/checkout/pub/orderForm/:orderFormId/installments" {:headers {:content-type ""
                                                                                                          :accept ""}
                                                                                                :query-params {:paymentSystem ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem="
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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem="),
    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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=");
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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem="

	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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem= HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem="))
    .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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=")
  .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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments',
  params: {paymentSystem: ''},
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=';
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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=")
  .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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=',
  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/checkout/pub/orderForm/:orderFormId/installments',
  qs: {paymentSystem: ''},
  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/checkout/pub/orderForm/:orderFormId/installments');

req.query({
  paymentSystem: ''
});

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/checkout/pub/orderForm/:orderFormId/installments',
  params: {paymentSystem: ''},
  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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=';
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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem="]
                                                       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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=" 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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=",
  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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'paymentSystem' => ''
]);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'paymentSystem' => ''
]));

$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/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments"

querystring = {"paymentSystem":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments"

queryString <- list(paymentSystem = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=")

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/checkout/pub/orderForm/:orderFormId/installments') do |req|
  req.headers['accept'] = ''
  req.params['paymentSystem'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments";

    let querystring = [
        ("paymentSystem", ""),
    ];

    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)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=' \
  --header 'accept: ' \
  --header 'content-type: '

http GET '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=' \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem='

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/installments?paymentSystem=")! 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()

POST Cart simulation

{{baseUrl}}/api/checkout/pub/orderForms/simulation

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForms/simulation");

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/post "{{baseUrl}}/api/checkout/pub/orderForms/simulation" {:headers {:content-type ""
                                                                                             :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForms/simulation"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForms/simulation"),
    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/checkout/pub/orderForms/simulation");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForms/simulation"

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

}

POST /baseUrl/api/checkout/pub/orderForms/simulation HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForms/simulation")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForms/simulation"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForms/simulation")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForms/simulation")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForms/simulation');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForms/simulation',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForms/simulation';
const options = {method: 'POST', 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/checkout/pub/orderForms/simulation',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForms/simulation")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForms/simulation',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForms/simulation',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForms/simulation');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForms/simulation',
  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/checkout/pub/orderForms/simulation';
const options = {method: 'POST', 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/checkout/pub/orderForms/simulation"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForms/simulation" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForms/simulation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForms/simulation', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForms/simulation');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForms/simulation');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForms/simulation' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForms/simulation' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForms/simulation", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForms/simulation"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForms/simulation"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForms/simulation")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForms/simulation') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForms/simulation \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForms/simulation \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForms/simulation

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForms/simulation")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

PUT Change price

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price

HEADERS

Content-Type

QUERY PARAMS

orderFormId

itemIndex

BODY json

{
  "price": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price");

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);

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price" {:headers {:accept ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:price 0}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}
reqBody = "{\n  \"price\": 0\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"price\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
request.AddParameter("", "{\n  \"price\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price"

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

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

	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))

}

PUT /baseUrl/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price HTTP/1.1
Content-Type: 
Accept: 
Host: example.com
Content-Length: 16

{
  "price": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .setBody("{\n  \"price\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price"))
    .header("content-type", "")
    .header("accept", "")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"price\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"price\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price")
  .put(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price")
  .header("content-type", "")
  .header("accept", "")
  .body("{\n  \"price\": 0\n}")
  .asString();

const data = JSON.stringify({
  price: 0
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price',
  headers: {'content-type': '', accept: ''},
  data: {price: 0}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price';
const options = {method: 'PUT', headers: {'content-type': '', accept: ''}, body: '{"price":0}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price',
  method: 'PUT',
  headers: {
    'content-type': '',
    accept: ''
  },
  processData: false,
  data: '{\n  "price": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"price\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price")
  .put(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price',
  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.write(JSON.stringify({price: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price',
  headers: {'content-type': '', accept: ''},
  body: {price: 0},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price');

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

req.type('json');
req.send({
  price: 0
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price',
  headers: {'content-type': '', accept: ''},
  data: {price: 0}
};

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

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price';
const options = {method: 'PUT', headers: {'content-type': '', accept: ''}, body: '{"price":0}'};

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price"]
                                                       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/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"price\": 0\n}" in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price",
  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([
    'price' => 0
  ]),
  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/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price', [
  'body' => '{
  "price": 0
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'price' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price');
$request->setRequestMethod('PUT');
$request->setBody($body);

$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/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price' -Method PUT -Headers $headers -ContentType '' -Body '{
  "price": 0
}'

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price' -Method PUT -Headers $headers -ContentType '' -Body '{
  "price": 0
}'

import http.client

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

payload = "{\n  \"price\": 0\n}"

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

conn.request("PUT", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price"

payload <- "{\n  \"price\": 0\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price")

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

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

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

require 'faraday'

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

response = conn.put('/baseUrl/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"price\": 0\n}"
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price";

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price \
  --header 'accept: ' \
  --header 'content-type: ' \
  --data '{
  "price": 0
}'

echo '{
  "price": 0
}' |  \
  http PUT {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price \
  accept:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'content-type: ' \
  --header 'accept: ' \
  --body-data '{\n  "price": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/:itemIndex/price")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "allowManualPrice": true,
  "canEditData": true,
  "checkedInPickupPointId": null,
  "clientPreferencesData": {
    "locale": "pt-BR",
    "optinNewsLetter": null
  },
  "clientProfileData": null,
  "commercialConditionData": null,
  "customData": null,
  "giftRegistryData": null,
  "hooksData": null,
  "ignoreProfileData": false,
  "invoiceData": null,
  "isCheckedIn": false,
  "itemMetadata": {
    "items": [
      {
        "assemblyOptions": [],
        "detailUrl": "/racao-royal-canin-feline-urinary/p",
        "ean": "123456789",
        "id": "1",
        "imageUrl": "http://lojadobreno.vteximg.com.br/arquivos/ids/155450-55-55/Racao-Royal-Canin-Feline-Urinary-SO.jpg?v=637139444438700000",
        "name": "Ração Royal Canin Feline Urinary 500g",
        "productId": "1",
        "refId": "0001",
        "seller": "1",
        "skuName": "Ração Royal Canin Feline Urinary 500g"
      }
    ]
  },
  "items": [
    {
      "additionalInfo": {
        "brandId": "2000000",
        "brandName": "Royal Canin",
        "offeringInfo": null,
        "offeringType": null,
        "offeringTypeId": null
      },
      "assemblies": [],
      "attachmentOfferings": [],
      "attachments": [],
      "availability": "available",
      "bundleItems": [],
      "components": [],
      "detailUrl": "/racao-royal-canin-feline-urinary/p",
      "ean": "123456789",
      "id": "1",
      "imageUrl": "http://lojadobreno.vteximg.com.br/arquivos/ids/155450-55-55/Racao-Royal-Canin-Feline-Urinary-SO.jpg?v=637139444438700000",
      "isGift": false,
      "listPrice": 30000,
      "manualPrice": 10000,
      "manufacturerCode": null,
      "measurementUnit": "un",
      "modalType": null,
      "name": "Ração Royal Canin Feline Urinary 500g",
      "offerings": [],
      "parentAssemblyBinding": null,
      "parentItemIndex": null,
      "preSaleDate": null,
      "price": 15000,
      "priceTags": [
        {
          "identifier": null,
          "isPercentual": false,
          "name": "DISCOUNT@MANUALPRICE",
          "rawValue": -50,
          "value": -5000
        }
      ],
      "priceValidUntil": "2021-02-27T14:59:00.8288784Z",
      "productCategories": {
        "1": "Alimentação",
        "10": "Ração Seca"
      },
      "productCategoryIds": "/1/10/",
      "productId": "1",
      "productRefId": "",
      "quantity": 1,
      "refId": "0001",
      "rewardValue": 0,
      "seller": "1",
      "sellerChain": [
        "1"
      ],
      "sellingPrice": 10000,
      "skuName": "Ração Royal Canin Feline Urinary 500g",
      "tax": 0,
      "uniqueId": "E0F2B7AF5CD74D668F1E27537206912C",
      "unitMultiplier": 1
    }
  ],
  "itemsOrdination": null,
  "loggedIn": true,
  "marketingData": null,
  "messages": [],
  "openTextField": null,
  "orderFormId": "ede846222cd44046ba6c638442c3505a",
  "paymentData": {
    "availableAccounts": [],
    "availableTokens": [],
    "giftCardMessages": [],
    "giftCards": [],
    "installmentOptions": [
      {
        "bin": null,
        "installments": [
          {
            "count": 1,
            "hasInterestRate": false,
            "interestRate": 0,
            "sellerMerchantInstallments": [
              {
                "count": 1,
                "hasInterestRate": false,
                "id": "LOJADOBRENO",
                "interestRate": 0,
                "total": 10000,
                "value": 10000
              }
            ],
            "total": 10000,
            "value": 10000
          },
          {
            "count": 2,
            "hasInterestRate": false,
            "interestRate": 0,
            "sellerMerchantInstallments": [
              {
                "count": 2,
                "hasInterestRate": false,
                "id": "LOJADOBRENO",
                "interestRate": 0,
                "total": 10000,
                "value": 5000
              }
            ],
            "total": 10000,
            "value": 5000
          }
        ],
        "paymentGroupName": null,
        "paymentName": null,
        "paymentSystem": "2",
        "value": 10000
      }
    ],
    "paymentSystems": [
      {
        "availablePayments": null,
        "description": null,
        "dueDate": "2020-03-05T16:42:31.7836281Z",
        "groupName": "creditCardPaymentGroup",
        "id": 2,
        "isCustom": false,
        "name": "Visa",
        "requiresAuthentication": false,
        "requiresDocument": false,
        "stringId": "2",
        "template": "creditCardPaymentGroup-template",
        "validator": {
          "cardCodeMask": "999",
          "cardCodeRegex": "^[0-9]{3}$",
          "mask": "9999 9999 9999 9999",
          "regex": "^4[0-9]{15}$",
          "useBillingAddress": true,
          "useCardHolderName": true,
          "useCvv": true,
          "useExpirationDate": true,
          "weights": [
            2,
            1,
            2,
            1,
            2
          ]
        }
      }
    ],
    "payments": []
  },
  "ratesAndBenefitsData": {
    "rateAndBenefitsIdentifiers": [],
    "teaser": []
  },
  "salesChannel": "1",
  "selectableGifts": [],
  "sellers": [
    {
      "id": "1",
      "logo": "",
      "name": "lojadobreno"
    }
  ],
  "shippingData": {
    "address": null,
    "availableAddresses": [],
    "logisticsInfo": [
      {
        "addressId": null,
        "deliveryChannels": [
          {
            "id": "pickup-in-point"
          },
          {
            "id": "delivery"
          }
        ],
        "itemId": "1",
        "itemIndex": 0,
        "selectedDeliveryChannel": "delivery",
        "selectedSla": null,
        "shipsTo": [
          "BRA"
        ],
        "slas": []
      }
    ],
    "pickupPoints": [],
    "selectedAddresses": []
  },
  "storeId": null,
  "storePreferencesData": {
    "countryCode": "BRA",
    "currencyCode": "BRL",
    "currencyFormatInfo": {
      "currencyDecimalDigits": 2,
      "currencyDecimalSeparator": ",",
      "currencyGroupSeparator": ".",
      "currencyGroupSize": 3,
      "startsWithCurrencySymbol": true
    },
    "currencyLocale": 1046,
    "currencySymbol": "R$",
    "saveUserData": true,
    "timeZone": "E. South America Standard Time"
  },
  "subscriptionData": null,
  "totalizers": [
    {
      "id": "Items",
      "name": "Total dos Itens",
      "value": 15000
    },
    {
      "id": "Discounts",
      "name": "Total dos Descontos",
      "value": -5000
    }
  ],
  "userProfileId": null,
  "userType": null,
  "value": 10000
}

GET Get cart information by ID

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId");

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/checkout/pub/orderForm/:orderFormId" {:headers {:content-type ""
                                                                                             :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId"
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/checkout/pub/orderForm/:orderFormId"),
    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/checkout/pub/orderForm/:orderFormId");
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/checkout/pub/orderForm/:orderFormId"

	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/checkout/pub/orderForm/:orderFormId HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId"))
    .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/checkout/pub/orderForm/:orderFormId")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId")
  .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/checkout/pub/orderForm/:orderFormId');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId';
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/checkout/pub/orderForm/:orderFormId',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId")
  .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/checkout/pub/orderForm/:orderFormId',
  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/checkout/pub/orderForm/:orderFormId',
  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/checkout/pub/orderForm/:orderFormId');

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/checkout/pub/orderForm/:orderFormId',
  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/checkout/pub/orderForm/:orderFormId';
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/checkout/pub/orderForm/:orderFormId"]
                                                       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/checkout/pub/orderForm/:orderFormId" 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/checkout/pub/orderForm/:orderFormId",
  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/checkout/pub/orderForm/:orderFormId', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId');
$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/checkout/pub/orderForm/:orderFormId');
$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/checkout/pub/orderForm/:orderFormId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/api/checkout/pub/orderForm/:orderFormId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId")

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/checkout/pub/orderForm/:orderFormId') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    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);
}

curl --request GET \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId")! 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()

GET Get current or create a new cart

{{baseUrl}}/api/checkout/pub/orderForm

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm");

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/checkout/pub/orderForm" {:headers {:content-type ""
                                                                                :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm"
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/checkout/pub/orderForm"),
    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/checkout/pub/orderForm");
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/checkout/pub/orderForm"

	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/checkout/pub/orderForm HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm"))
    .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/checkout/pub/orderForm")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pub/orderForm")
  .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/checkout/pub/orderForm');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pub/orderForm',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm';
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/checkout/pub/orderForm',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm")
  .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/checkout/pub/orderForm',
  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/checkout/pub/orderForm',
  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/checkout/pub/orderForm');

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/checkout/pub/orderForm',
  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/checkout/pub/orderForm';
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/checkout/pub/orderForm"]
                                                       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/checkout/pub/orderForm" 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/checkout/pub/orderForm",
  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/checkout/pub/orderForm', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm');
$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/checkout/pub/orderForm');
$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/checkout/pub/orderForm' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/api/checkout/pub/orderForm", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm")

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/checkout/pub/orderForm') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    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);
}

curl --request GET \
  --url {{baseUrl}}/api/checkout/pub/orderForm \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/checkout/pub/orderForm \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm

import Foundation

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

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

PATCH Ignore profile data

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile");

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/patch "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile" {:headers {:content-type ""
                                                                                                       :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile"),
    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/checkout/pub/orderForm/:orderFormId/profile");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile"

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

}

PATCH /baseUrl/api/checkout/pub/orderForm/:orderFormId/profile HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile"))
    .header("content-type", "")
    .header("accept", "")
    .method("PATCH", 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/checkout/pub/orderForm/:orderFormId/profile")
  .patch(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile")
  .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('PATCH', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile';
const options = {method: 'PATCH', 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/checkout/pub/orderForm/:orderFormId/profile',
  method: 'PATCH',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile")
  .patch(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/profile',
  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: 'PATCH',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile',
  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('PATCH', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile');

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: 'PATCH',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile',
  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/checkout/pub/orderForm/:orderFormId/profile';
const options = {method: 'PATCH', 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/checkout/pub/orderForm/:orderFormId/profile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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/checkout/pub/orderForm/:orderFormId/profile" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  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('PATCH', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile');
$request->setRequestMethod('PATCH');
$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/checkout/pub/orderForm/:orderFormId/profile' -Method PATCH -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile' -Method PATCH -Headers $headers

import http.client

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

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

conn.request("PATCH", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/profile", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile")

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

request = Net::HTTP::Patch.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.patch('/baseUrl/api/checkout/pub/orderForm/:orderFormId/profile') 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/checkout/pub/orderForm/:orderFormId/profile";

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

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile \
  --header 'accept: ' \
  --header 'content-type: '

http PATCH {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile \
  accept:'' \
  content-type:''

wget --quiet \
  --method PATCH \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/profile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

POST Remove all items

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll" {:headers {:content-type ""
                                                                                                              :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll"),
    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/checkout/pub/orderForm/:orderFormId/items/removeAll");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/items/removeAll HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/items/removeAll',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/items/removeAll',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll',
  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/checkout/pub/orderForm/:orderFormId/items/removeAll';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/items/removeAll"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/items/removeAll" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/items/removeAll', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/items/removeAll' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/items/removeAll", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/items/removeAll') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/removeAll")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()

GET Remove all personal data

{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId");

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}}/checkout/changeToAnonymousUser/:orderFormId" {:headers {:content-type ""
                                                                                                 :accept ""}})

require "http/client"

url = "{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId"
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}}/checkout/changeToAnonymousUser/:orderFormId"),
    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}}/checkout/changeToAnonymousUser/:orderFormId");
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}}/checkout/changeToAnonymousUser/:orderFormId"

	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/checkout/changeToAnonymousUser/:orderFormId HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId"))
    .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}}/checkout/changeToAnonymousUser/:orderFormId")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId")
  .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}}/checkout/changeToAnonymousUser/:orderFormId');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId';
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}}/checkout/changeToAnonymousUser/:orderFormId',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

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

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}}/checkout/changeToAnonymousUser/:orderFormId',
  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}}/checkout/changeToAnonymousUser/:orderFormId';
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}}/checkout/changeToAnonymousUser/:orderFormId"]
                                                       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}}/checkout/changeToAnonymousUser/:orderFormId" 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}}/checkout/changeToAnonymousUser/:orderFormId",
  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}}/checkout/changeToAnonymousUser/:orderFormId', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId');
$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}}/checkout/changeToAnonymousUser/:orderFormId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId' -Method GET -Headers $headers

import http.client

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

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

conn.request("GET", "/baseUrl/checkout/changeToAnonymousUser/:orderFormId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId")

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/checkout/changeToAnonymousUser/:orderFormId') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    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);
}

curl --request GET \
  --url {{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/checkout/changeToAnonymousUser/:orderFormId

import Foundation

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

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

POST Update cart items

{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update

HEADERS

Content-Type

QUERY PARAMS

orderFormId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update");

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/post "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update" {:headers {:content-type ""
                                                                                                           :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update"),
    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/checkout/pub/orderForm/:orderFormId/items/update");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update"

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

}

POST /baseUrl/api/checkout/pub/orderForm/:orderFormId/items/update HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update")
  .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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update',
  headers: {'content-type': '', accept: ''}
};

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

const url = '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/items/update',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pub/orderForm/:orderFormId/items/update',
  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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update',
  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('POST', '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update');

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: 'POST',
  url: '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update',
  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/checkout/pub/orderForm/:orderFormId/items/update';
const options = {method: 'POST', 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/checkout/pub/orderForm/:orderFormId/items/update"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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/checkout/pub/orderForm/:orderFormId/items/update" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

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

 "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  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/checkout/pub/orderForm/:orderFormId/items/update', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update');
$request->setRequestMethod('POST');
$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/checkout/pub/orderForm/:orderFormId/items/update' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update' -Method POST -Headers $headers

import http.client

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

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

conn.request("POST", "/baseUrl/api/checkout/pub/orderForm/:orderFormId/items/update", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update")

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

request = Net::HTTP::Post.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.post('/baseUrl/api/checkout/pub/orderForm/:orderFormId/items/update') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update";

    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.post(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update

import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pub/orderForm/:orderFormId/items/update")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()