POST airtravelCoordinates
{{baseUrl}}/airtravelCoordinates
HEADERS
Content-Type
BODY formUrlEncoded
apiKey_l1
apiKey_l2
destination_airport_latitude
destination_airport_longitude
number_of_passengers
origin_airport_latitude
origin_airport_longitude
travel_class
travel_mode
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelCoordinates");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/airtravelCoordinates" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/airtravelCoordinates"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/airtravelCoordinates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/airtravelCoordinates");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

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

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
POST /baseUrl/airtravelCoordinates HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/airtravelCoordinates")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelCoordinates"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/airtravelCoordinates")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/airtravelCoordinates")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/airtravelCoordinates');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/airtravelCoordinates',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelCoordinates';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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}}/airtravelCoordinates',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/airtravelCoordinates")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelCoordinates',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/airtravelCoordinates',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/airtravelCoordinates');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/airtravelCoordinates',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelCoordinates';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelCoordinates"]
                                                       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}}/airtravelCoordinates" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelCoordinates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/airtravelCoordinates', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelCoordinates');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/airtravelCoordinates');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelCoordinates' -Method POST -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelCoordinates' -Method POST -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

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

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

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

url = "{{baseUrl}}/airtravelCoordinates"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

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

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/airtravelCoordinates') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/airtravelCoordinates \
  --header 'content-type: application/x-www-form-urlencoded'
http POST {{baseUrl}}/airtravelCoordinates \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/airtravelCoordinates
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelCoordinates")! 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()
PATCH confirmCarbonOffset
{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset
BODY formUrlEncoded
carbonOffset
contactEmail
contactFirstName
contactLastName
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/airtravelCoordinates/confirmCarbonOffset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/airtravelCoordinates/confirmCarbonOffset HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/airtravelCoordinates/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/airtravelCoordinates/confirmCarbonOffset');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/airtravelCoordinates/confirmCarbonOffset',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelCoordinates/confirmCarbonOffset',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/airtravelCoordinates/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/airtravelCoordinates/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset"]
                                                       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}}/airtravelCoordinates/confirmCarbonOffset" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/airtravelCoordinates/confirmCarbonOffset", payload, headers)

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

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

url = "{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/airtravelCoordinates/confirmCarbonOffset') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/airtravelCoordinates/confirmCarbonOffset \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/airtravelCoordinates/confirmCarbonOffset \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/airtravelCoordinates/confirmCarbonOffset
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelCoordinates/confirmCarbonOffset")! 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()
PATCH confirmPayment
{{baseUrl}}/airtravelCoordinates/confirmPayment
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPayment
paymentID
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelCoordinates/confirmPayment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/airtravelCoordinates/confirmPayment" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/airtravelCoordinates/confirmPayment"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/airtravelCoordinates/confirmPayment"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/airtravelCoordinates/confirmPayment");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/airtravelCoordinates/confirmPayment"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/airtravelCoordinates/confirmPayment HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/airtravelCoordinates/confirmPayment")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelCoordinates/confirmPayment"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/airtravelCoordinates/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/airtravelCoordinates/confirmPayment")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/airtravelCoordinates/confirmPayment');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/airtravelCoordinates/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelCoordinates/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/airtravelCoordinates/confirmPayment',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/airtravelCoordinates/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelCoordinates/confirmPayment',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/airtravelCoordinates/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/airtravelCoordinates/confirmPayment');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/airtravelCoordinates/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelCoordinates/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelCoordinates/confirmPayment"]
                                                       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}}/airtravelCoordinates/confirmPayment" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelCoordinates/confirmPayment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/airtravelCoordinates/confirmPayment', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelCoordinates/confirmPayment');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/airtravelCoordinates/confirmPayment');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelCoordinates/confirmPayment' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelCoordinates/confirmPayment' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/airtravelCoordinates/confirmPayment", payload, headers)

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

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

url = "{{baseUrl}}/airtravelCoordinates/confirmPayment"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/airtravelCoordinates/confirmPayment"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/airtravelCoordinates/confirmPayment")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/airtravelCoordinates/confirmPayment') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/airtravelCoordinates/confirmPayment \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/airtravelCoordinates/confirmPayment \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/airtravelCoordinates/confirmPayment
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelCoordinates/confirmPayment")! 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()
PATCH confirmPlanting
{{baseUrl}}/airtravelCoordinates/confirmPlanting
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPlanting
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelCoordinates/confirmPlanting");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/airtravelCoordinates/confirmPlanting" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/airtravelCoordinates/confirmPlanting"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/airtravelCoordinates/confirmPlanting"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/airtravelCoordinates/confirmPlanting");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/airtravelCoordinates/confirmPlanting"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/airtravelCoordinates/confirmPlanting HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/airtravelCoordinates/confirmPlanting")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelCoordinates/confirmPlanting"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/airtravelCoordinates/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/airtravelCoordinates/confirmPlanting")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/airtravelCoordinates/confirmPlanting');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/airtravelCoordinates/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelCoordinates/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/airtravelCoordinates/confirmPlanting',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/airtravelCoordinates/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelCoordinates/confirmPlanting',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/airtravelCoordinates/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/airtravelCoordinates/confirmPlanting');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/airtravelCoordinates/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelCoordinates/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelCoordinates/confirmPlanting"]
                                                       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}}/airtravelCoordinates/confirmPlanting" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelCoordinates/confirmPlanting",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/airtravelCoordinates/confirmPlanting', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelCoordinates/confirmPlanting');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/airtravelCoordinates/confirmPlanting');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelCoordinates/confirmPlanting' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelCoordinates/confirmPlanting' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/airtravelCoordinates/confirmPlanting", payload, headers)

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

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

url = "{{baseUrl}}/airtravelCoordinates/confirmPlanting"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/airtravelCoordinates/confirmPlanting"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/airtravelCoordinates/confirmPlanting")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/airtravelCoordinates/confirmPlanting') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/airtravelCoordinates/confirmPlanting \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/airtravelCoordinates/confirmPlanting \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/airtravelCoordinates/confirmPlanting
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelCoordinates/confirmPlanting")! 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()
PATCH confirmTransaction
{{baseUrl}}/airtravelCoordinates/confirmTransaction
BODY formUrlEncoded
confirmTransaction
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelCoordinates/confirmTransaction");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/airtravelCoordinates/confirmTransaction" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/airtravelCoordinates/confirmTransaction"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/airtravelCoordinates/confirmTransaction"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/airtravelCoordinates/confirmTransaction");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/airtravelCoordinates/confirmTransaction"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/airtravelCoordinates/confirmTransaction HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/airtravelCoordinates/confirmTransaction")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelCoordinates/confirmTransaction"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/airtravelCoordinates/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/airtravelCoordinates/confirmTransaction")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/airtravelCoordinates/confirmTransaction');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/airtravelCoordinates/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelCoordinates/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/airtravelCoordinates/confirmTransaction',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/airtravelCoordinates/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelCoordinates/confirmTransaction',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/airtravelCoordinates/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/airtravelCoordinates/confirmTransaction');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/airtravelCoordinates/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelCoordinates/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelCoordinates/confirmTransaction"]
                                                       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}}/airtravelCoordinates/confirmTransaction" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelCoordinates/confirmTransaction",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/airtravelCoordinates/confirmTransaction', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelCoordinates/confirmTransaction');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/airtravelCoordinates/confirmTransaction');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelCoordinates/confirmTransaction' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelCoordinates/confirmTransaction' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/airtravelCoordinates/confirmTransaction", payload, headers)

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

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

url = "{{baseUrl}}/airtravelCoordinates/confirmTransaction"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/airtravelCoordinates/confirmTransaction"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/airtravelCoordinates/confirmTransaction")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/airtravelCoordinates/confirmTransaction') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/airtravelCoordinates/confirmTransaction \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/airtravelCoordinates/confirmTransaction \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/airtravelCoordinates/confirmTransaction
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelCoordinates/confirmTransaction")! 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 airtravelMultileg
{{baseUrl}}/airtravelMultileg
BODY json
{
  "apiKey_l1": "",
  "apiKey_l2": "",
  "contactEmail": "",
  "contactFirstName": "",
  "contactLastName": "",
  "leg1": {
    "destination_airport_code": "",
    "origin_airport_code": "",
    "travel_class": ""
  },
  "leg2": {},
  "leg3": {},
  "legs_count": "",
  "number_of_passengers": "",
  "travel_mode": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelMultileg");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/airtravelMultileg" {:content-type :json
                                                              :form-params {:apiKey_l1 "d95fead6-e8a6-4547-9fb9-7835101a3960"
                                                                            :apiKey_l2 "c60f8db5-7204-4427-960d-27400c38b166"
                                                                            :leg1 {:destination_airport_code "DXB"
                                                                                   :origin_airport_code "KHI"
                                                                                   :travel_class "Economy"}
                                                                            :leg2 {:destination_airport_code "LHR"
                                                                                   :origin_airport_code "DXB"
                                                                                   :travel_class "Business"}
                                                                            :leg3 {:destination_airport_code "KHI"
                                                                                   :origin_airport_code "FRA"
                                                                                   :travel_class "Premium Economy"}
                                                                            :legs_count "2"
                                                                            :number_of_passengers "2"
                                                                            :travel_mode "multileg"}})
require "http/client"

url = "{{baseUrl}}/airtravelMultileg"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\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}}/airtravelMultileg"),
    Content = new StringContent("{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\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}}/airtravelMultileg");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}")

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

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

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

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

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

}
POST /baseUrl/airtravelMultileg HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 562

{
  "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",
  "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",
  "leg1": {
    "destination_airport_code": "DXB",
    "origin_airport_code": "KHI",
    "travel_class": "Economy"
  },
  "leg2": {
    "destination_airport_code": "LHR",
    "origin_airport_code": "DXB",
    "travel_class": "Business"
  },
  "leg3": {
    "destination_airport_code": "KHI",
    "origin_airport_code": "FRA",
    "travel_class": "Premium Economy"
  },
  "legs_count": "2",
  "number_of_passengers": "2",
  "travel_mode": "multileg"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/airtravelMultileg")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelMultileg"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\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  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/airtravelMultileg")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/airtravelMultileg")
  .header("content-type", "application/json")
  .body("{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}")
  .asString();
const data = JSON.stringify({
  apiKey_l1: 'd95fead6-e8a6-4547-9fb9-7835101a3960',
  apiKey_l2: 'c60f8db5-7204-4427-960d-27400c38b166',
  leg1: {
    destination_airport_code: 'DXB',
    origin_airport_code: 'KHI',
    travel_class: 'Economy'
  },
  leg2: {
    destination_airport_code: 'LHR',
    origin_airport_code: 'DXB',
    travel_class: 'Business'
  },
  leg3: {
    destination_airport_code: 'KHI',
    origin_airport_code: 'FRA',
    travel_class: 'Premium Economy'
  },
  legs_count: '2',
  number_of_passengers: '2',
  travel_mode: 'multileg'
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/airtravelMultileg',
  headers: {'content-type': 'application/json'},
  data: {
    apiKey_l1: 'd95fead6-e8a6-4547-9fb9-7835101a3960',
    apiKey_l2: 'c60f8db5-7204-4427-960d-27400c38b166',
    leg1: {
      destination_airport_code: 'DXB',
      origin_airport_code: 'KHI',
      travel_class: 'Economy'
    },
    leg2: {
      destination_airport_code: 'LHR',
      origin_airport_code: 'DXB',
      travel_class: 'Business'
    },
    leg3: {
      destination_airport_code: 'KHI',
      origin_airport_code: 'FRA',
      travel_class: 'Premium Economy'
    },
    legs_count: '2',
    number_of_passengers: '2',
    travel_mode: 'multileg'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelMultileg';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"apiKey_l1":"d95fead6-e8a6-4547-9fb9-7835101a3960","apiKey_l2":"c60f8db5-7204-4427-960d-27400c38b166","leg1":{"destination_airport_code":"DXB","origin_airport_code":"KHI","travel_class":"Economy"},"leg2":{"destination_airport_code":"LHR","origin_airport_code":"DXB","travel_class":"Business"},"leg3":{"destination_airport_code":"KHI","origin_airport_code":"FRA","travel_class":"Premium Economy"},"legs_count":"2","number_of_passengers":"2","travel_mode":"multileg"}'
};

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}}/airtravelMultileg',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",\n  "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",\n  "leg1": {\n    "destination_airport_code": "DXB",\n    "origin_airport_code": "KHI",\n    "travel_class": "Economy"\n  },\n  "leg2": {\n    "destination_airport_code": "LHR",\n    "origin_airport_code": "DXB",\n    "travel_class": "Business"\n  },\n  "leg3": {\n    "destination_airport_code": "KHI",\n    "origin_airport_code": "FRA",\n    "travel_class": "Premium Economy"\n  },\n  "legs_count": "2",\n  "number_of_passengers": "2",\n  "travel_mode": "multileg"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/airtravelMultileg")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelMultileg',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  apiKey_l1: 'd95fead6-e8a6-4547-9fb9-7835101a3960',
  apiKey_l2: 'c60f8db5-7204-4427-960d-27400c38b166',
  leg1: {
    destination_airport_code: 'DXB',
    origin_airport_code: 'KHI',
    travel_class: 'Economy'
  },
  leg2: {
    destination_airport_code: 'LHR',
    origin_airport_code: 'DXB',
    travel_class: 'Business'
  },
  leg3: {
    destination_airport_code: 'KHI',
    origin_airport_code: 'FRA',
    travel_class: 'Premium Economy'
  },
  legs_count: '2',
  number_of_passengers: '2',
  travel_mode: 'multileg'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/airtravelMultileg',
  headers: {'content-type': 'application/json'},
  body: {
    apiKey_l1: 'd95fead6-e8a6-4547-9fb9-7835101a3960',
    apiKey_l2: 'c60f8db5-7204-4427-960d-27400c38b166',
    leg1: {
      destination_airport_code: 'DXB',
      origin_airport_code: 'KHI',
      travel_class: 'Economy'
    },
    leg2: {
      destination_airport_code: 'LHR',
      origin_airport_code: 'DXB',
      travel_class: 'Business'
    },
    leg3: {
      destination_airport_code: 'KHI',
      origin_airport_code: 'FRA',
      travel_class: 'Premium Economy'
    },
    legs_count: '2',
    number_of_passengers: '2',
    travel_mode: 'multileg'
  },
  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}}/airtravelMultileg');

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

req.type('json');
req.send({
  apiKey_l1: 'd95fead6-e8a6-4547-9fb9-7835101a3960',
  apiKey_l2: 'c60f8db5-7204-4427-960d-27400c38b166',
  leg1: {
    destination_airport_code: 'DXB',
    origin_airport_code: 'KHI',
    travel_class: 'Economy'
  },
  leg2: {
    destination_airport_code: 'LHR',
    origin_airport_code: 'DXB',
    travel_class: 'Business'
  },
  leg3: {
    destination_airport_code: 'KHI',
    origin_airport_code: 'FRA',
    travel_class: 'Premium Economy'
  },
  legs_count: '2',
  number_of_passengers: '2',
  travel_mode: 'multileg'
});

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}}/airtravelMultileg',
  headers: {'content-type': 'application/json'},
  data: {
    apiKey_l1: 'd95fead6-e8a6-4547-9fb9-7835101a3960',
    apiKey_l2: 'c60f8db5-7204-4427-960d-27400c38b166',
    leg1: {
      destination_airport_code: 'DXB',
      origin_airport_code: 'KHI',
      travel_class: 'Economy'
    },
    leg2: {
      destination_airport_code: 'LHR',
      origin_airport_code: 'DXB',
      travel_class: 'Business'
    },
    leg3: {
      destination_airport_code: 'KHI',
      origin_airport_code: 'FRA',
      travel_class: 'Premium Economy'
    },
    legs_count: '2',
    number_of_passengers: '2',
    travel_mode: 'multileg'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelMultileg';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"apiKey_l1":"d95fead6-e8a6-4547-9fb9-7835101a3960","apiKey_l2":"c60f8db5-7204-4427-960d-27400c38b166","leg1":{"destination_airport_code":"DXB","origin_airport_code":"KHI","travel_class":"Economy"},"leg2":{"destination_airport_code":"LHR","origin_airport_code":"DXB","travel_class":"Business"},"leg3":{"destination_airport_code":"KHI","origin_airport_code":"FRA","travel_class":"Premium Economy"},"legs_count":"2","number_of_passengers":"2","travel_mode":"multileg"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"apiKey_l1": @"d95fead6-e8a6-4547-9fb9-7835101a3960",
                              @"apiKey_l2": @"c60f8db5-7204-4427-960d-27400c38b166",
                              @"leg1": @{ @"destination_airport_code": @"DXB", @"origin_airport_code": @"KHI", @"travel_class": @"Economy" },
                              @"leg2": @{ @"destination_airport_code": @"LHR", @"origin_airport_code": @"DXB", @"travel_class": @"Business" },
                              @"leg3": @{ @"destination_airport_code": @"KHI", @"origin_airport_code": @"FRA", @"travel_class": @"Premium Economy" },
                              @"legs_count": @"2",
                              @"number_of_passengers": @"2",
                              @"travel_mode": @"multileg" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelMultileg"]
                                                       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}}/airtravelMultileg" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelMultileg",
  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([
    'apiKey_l1' => 'd95fead6-e8a6-4547-9fb9-7835101a3960',
    'apiKey_l2' => 'c60f8db5-7204-4427-960d-27400c38b166',
    'leg1' => [
        'destination_airport_code' => 'DXB',
        'origin_airport_code' => 'KHI',
        'travel_class' => 'Economy'
    ],
    'leg2' => [
        'destination_airport_code' => 'LHR',
        'origin_airport_code' => 'DXB',
        'travel_class' => 'Business'
    ],
    'leg3' => [
        'destination_airport_code' => 'KHI',
        'origin_airport_code' => 'FRA',
        'travel_class' => 'Premium Economy'
    ],
    'legs_count' => '2',
    'number_of_passengers' => '2',
    'travel_mode' => 'multileg'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/airtravelMultileg', [
  'body' => '{
  "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",
  "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",
  "leg1": {
    "destination_airport_code": "DXB",
    "origin_airport_code": "KHI",
    "travel_class": "Economy"
  },
  "leg2": {
    "destination_airport_code": "LHR",
    "origin_airport_code": "DXB",
    "travel_class": "Business"
  },
  "leg3": {
    "destination_airport_code": "KHI",
    "origin_airport_code": "FRA",
    "travel_class": "Premium Economy"
  },
  "legs_count": "2",
  "number_of_passengers": "2",
  "travel_mode": "multileg"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelMultileg');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'apiKey_l1' => 'd95fead6-e8a6-4547-9fb9-7835101a3960',
  'apiKey_l2' => 'c60f8db5-7204-4427-960d-27400c38b166',
  'leg1' => [
    'destination_airport_code' => 'DXB',
    'origin_airport_code' => 'KHI',
    'travel_class' => 'Economy'
  ],
  'leg2' => [
    'destination_airport_code' => 'LHR',
    'origin_airport_code' => 'DXB',
    'travel_class' => 'Business'
  ],
  'leg3' => [
    'destination_airport_code' => 'KHI',
    'origin_airport_code' => 'FRA',
    'travel_class' => 'Premium Economy'
  ],
  'legs_count' => '2',
  'number_of_passengers' => '2',
  'travel_mode' => 'multileg'
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'apiKey_l1' => 'd95fead6-e8a6-4547-9fb9-7835101a3960',
  'apiKey_l2' => 'c60f8db5-7204-4427-960d-27400c38b166',
  'leg1' => [
    'destination_airport_code' => 'DXB',
    'origin_airport_code' => 'KHI',
    'travel_class' => 'Economy'
  ],
  'leg2' => [
    'destination_airport_code' => 'LHR',
    'origin_airport_code' => 'DXB',
    'travel_class' => 'Business'
  ],
  'leg3' => [
    'destination_airport_code' => 'KHI',
    'origin_airport_code' => 'FRA',
    'travel_class' => 'Premium Economy'
  ],
  'legs_count' => '2',
  'number_of_passengers' => '2',
  'travel_mode' => 'multileg'
]));
$request->setRequestUrl('{{baseUrl}}/airtravelMultileg');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelMultileg' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",
  "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",
  "leg1": {
    "destination_airport_code": "DXB",
    "origin_airport_code": "KHI",
    "travel_class": "Economy"
  },
  "leg2": {
    "destination_airport_code": "LHR",
    "origin_airport_code": "DXB",
    "travel_class": "Business"
  },
  "leg3": {
    "destination_airport_code": "KHI",
    "origin_airport_code": "FRA",
    "travel_class": "Premium Economy"
  },
  "legs_count": "2",
  "number_of_passengers": "2",
  "travel_mode": "multileg"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelMultileg' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",
  "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",
  "leg1": {
    "destination_airport_code": "DXB",
    "origin_airport_code": "KHI",
    "travel_class": "Economy"
  },
  "leg2": {
    "destination_airport_code": "LHR",
    "origin_airport_code": "DXB",
    "travel_class": "Business"
  },
  "leg3": {
    "destination_airport_code": "KHI",
    "origin_airport_code": "FRA",
    "travel_class": "Premium Economy"
  },
  "legs_count": "2",
  "number_of_passengers": "2",
  "travel_mode": "multileg"
}'
import http.client

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

payload = "{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}"

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

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

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

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

url = "{{baseUrl}}/airtravelMultileg"

payload = {
    "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",
    "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",
    "leg1": {
        "destination_airport_code": "DXB",
        "origin_airport_code": "KHI",
        "travel_class": "Economy"
    },
    "leg2": {
        "destination_airport_code": "LHR",
        "origin_airport_code": "DXB",
        "travel_class": "Business"
    },
    "leg3": {
        "destination_airport_code": "KHI",
        "origin_airport_code": "FRA",
        "travel_class": "Premium Economy"
    },
    "legs_count": "2",
    "number_of_passengers": "2",
    "travel_mode": "multileg"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

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

payload <- "{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\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}}/airtravelMultileg")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\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/airtravelMultileg') do |req|
  req.body = "{\n  \"apiKey_l1\": \"d95fead6-e8a6-4547-9fb9-7835101a3960\",\n  \"apiKey_l2\": \"c60f8db5-7204-4427-960d-27400c38b166\",\n  \"leg1\": {\n    \"destination_airport_code\": \"DXB\",\n    \"origin_airport_code\": \"KHI\",\n    \"travel_class\": \"Economy\"\n  },\n  \"leg2\": {\n    \"destination_airport_code\": \"LHR\",\n    \"origin_airport_code\": \"DXB\",\n    \"travel_class\": \"Business\"\n  },\n  \"leg3\": {\n    \"destination_airport_code\": \"KHI\",\n    \"origin_airport_code\": \"FRA\",\n    \"travel_class\": \"Premium Economy\"\n  },\n  \"legs_count\": \"2\",\n  \"number_of_passengers\": \"2\",\n  \"travel_mode\": \"multileg\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",
        "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",
        "leg1": json!({
            "destination_airport_code": "DXB",
            "origin_airport_code": "KHI",
            "travel_class": "Economy"
        }),
        "leg2": json!({
            "destination_airport_code": "LHR",
            "origin_airport_code": "DXB",
            "travel_class": "Business"
        }),
        "leg3": json!({
            "destination_airport_code": "KHI",
            "origin_airport_code": "FRA",
            "travel_class": "Premium Economy"
        }),
        "legs_count": "2",
        "number_of_passengers": "2",
        "travel_mode": "multileg"
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/airtravelMultileg \
  --header 'content-type: application/json' \
  --data '{
  "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",
  "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",
  "leg1": {
    "destination_airport_code": "DXB",
    "origin_airport_code": "KHI",
    "travel_class": "Economy"
  },
  "leg2": {
    "destination_airport_code": "LHR",
    "origin_airport_code": "DXB",
    "travel_class": "Business"
  },
  "leg3": {
    "destination_airport_code": "KHI",
    "origin_airport_code": "FRA",
    "travel_class": "Premium Economy"
  },
  "legs_count": "2",
  "number_of_passengers": "2",
  "travel_mode": "multileg"
}'
echo '{
  "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",
  "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",
  "leg1": {
    "destination_airport_code": "DXB",
    "origin_airport_code": "KHI",
    "travel_class": "Economy"
  },
  "leg2": {
    "destination_airport_code": "LHR",
    "origin_airport_code": "DXB",
    "travel_class": "Business"
  },
  "leg3": {
    "destination_airport_code": "KHI",
    "origin_airport_code": "FRA",
    "travel_class": "Premium Economy"
  },
  "legs_count": "2",
  "number_of_passengers": "2",
  "travel_mode": "multileg"
}' |  \
  http POST {{baseUrl}}/airtravelMultileg \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",\n  "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",\n  "leg1": {\n    "destination_airport_code": "DXB",\n    "origin_airport_code": "KHI",\n    "travel_class": "Economy"\n  },\n  "leg2": {\n    "destination_airport_code": "LHR",\n    "origin_airport_code": "DXB",\n    "travel_class": "Business"\n  },\n  "leg3": {\n    "destination_airport_code": "KHI",\n    "origin_airport_code": "FRA",\n    "travel_class": "Premium Economy"\n  },\n  "legs_count": "2",\n  "number_of_passengers": "2",\n  "travel_mode": "multileg"\n}' \
  --output-document \
  - {{baseUrl}}/airtravelMultileg
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "apiKey_l1": "d95fead6-e8a6-4547-9fb9-7835101a3960",
  "apiKey_l2": "c60f8db5-7204-4427-960d-27400c38b166",
  "leg1": [
    "destination_airport_code": "DXB",
    "origin_airport_code": "KHI",
    "travel_class": "Economy"
  ],
  "leg2": [
    "destination_airport_code": "LHR",
    "origin_airport_code": "DXB",
    "travel_class": "Business"
  ],
  "leg3": [
    "destination_airport_code": "KHI",
    "origin_airport_code": "FRA",
    "travel_class": "Premium Economy"
  ],
  "legs_count": "2",
  "number_of_passengers": "2",
  "travel_mode": "multileg"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelMultileg")! 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()
PATCH confirmCarbonOffset (PATCH)
{{baseUrl}}/airtravelMultileg/confirmCarbonOffset
BODY formUrlEncoded
carbonOffset
contactEmail
contactFirstName
contactLastName
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelMultileg/confirmCarbonOffset");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/airtravelMultileg/confirmCarbonOffset" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/airtravelMultileg/confirmCarbonOffset"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/airtravelMultileg/confirmCarbonOffset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/airtravelMultileg/confirmCarbonOffset");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/airtravelMultileg/confirmCarbonOffset"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/airtravelMultileg/confirmCarbonOffset HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/airtravelMultileg/confirmCarbonOffset")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelMultileg/confirmCarbonOffset"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/airtravelMultileg/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/airtravelMultileg/confirmCarbonOffset")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/airtravelMultileg/confirmCarbonOffset');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/airtravelMultileg/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelMultileg/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/airtravelMultileg/confirmCarbonOffset',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/airtravelMultileg/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelMultileg/confirmCarbonOffset',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/airtravelMultileg/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/airtravelMultileg/confirmCarbonOffset');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/airtravelMultileg/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelMultileg/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelMultileg/confirmCarbonOffset"]
                                                       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}}/airtravelMultileg/confirmCarbonOffset" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelMultileg/confirmCarbonOffset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/airtravelMultileg/confirmCarbonOffset', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelMultileg/confirmCarbonOffset');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/airtravelMultileg/confirmCarbonOffset');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelMultileg/confirmCarbonOffset' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelMultileg/confirmCarbonOffset' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/airtravelMultileg/confirmCarbonOffset", payload, headers)

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

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

url = "{{baseUrl}}/airtravelMultileg/confirmCarbonOffset"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/airtravelMultileg/confirmCarbonOffset"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/airtravelMultileg/confirmCarbonOffset")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/airtravelMultileg/confirmCarbonOffset') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/airtravelMultileg/confirmCarbonOffset \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/airtravelMultileg/confirmCarbonOffset \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/airtravelMultileg/confirmCarbonOffset
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelMultileg/confirmCarbonOffset")! 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()
PATCH confirmPayment (PATCH)
{{baseUrl}}/airtravelMultileg/confirmPayment
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPayment
paymentID
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelMultileg/confirmPayment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/airtravelMultileg/confirmPayment" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/airtravelMultileg/confirmPayment"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/airtravelMultileg/confirmPayment"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/airtravelMultileg/confirmPayment");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/airtravelMultileg/confirmPayment"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/airtravelMultileg/confirmPayment HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/airtravelMultileg/confirmPayment")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelMultileg/confirmPayment"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/airtravelMultileg/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/airtravelMultileg/confirmPayment")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/airtravelMultileg/confirmPayment');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/airtravelMultileg/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelMultileg/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/airtravelMultileg/confirmPayment',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/airtravelMultileg/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelMultileg/confirmPayment',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/airtravelMultileg/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/airtravelMultileg/confirmPayment');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/airtravelMultileg/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelMultileg/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelMultileg/confirmPayment"]
                                                       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}}/airtravelMultileg/confirmPayment" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelMultileg/confirmPayment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/airtravelMultileg/confirmPayment', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelMultileg/confirmPayment');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/airtravelMultileg/confirmPayment');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelMultileg/confirmPayment' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelMultileg/confirmPayment' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/airtravelMultileg/confirmPayment", payload, headers)

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

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

url = "{{baseUrl}}/airtravelMultileg/confirmPayment"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/airtravelMultileg/confirmPayment"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/airtravelMultileg/confirmPayment")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/airtravelMultileg/confirmPayment') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/airtravelMultileg/confirmPayment \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/airtravelMultileg/confirmPayment \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/airtravelMultileg/confirmPayment
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelMultileg/confirmPayment")! 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()
PATCH confirmPlanting (PATCH)
{{baseUrl}}/airtravelMultileg/confirmPlanting
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPlanting
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelMultileg/confirmPlanting");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/airtravelMultileg/confirmPlanting" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/airtravelMultileg/confirmPlanting"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/airtravelMultileg/confirmPlanting"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/airtravelMultileg/confirmPlanting");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/airtravelMultileg/confirmPlanting"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/airtravelMultileg/confirmPlanting HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/airtravelMultileg/confirmPlanting")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelMultileg/confirmPlanting"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/airtravelMultileg/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/airtravelMultileg/confirmPlanting")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/airtravelMultileg/confirmPlanting');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/airtravelMultileg/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelMultileg/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/airtravelMultileg/confirmPlanting',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/airtravelMultileg/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelMultileg/confirmPlanting',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/airtravelMultileg/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/airtravelMultileg/confirmPlanting');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/airtravelMultileg/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelMultileg/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelMultileg/confirmPlanting"]
                                                       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}}/airtravelMultileg/confirmPlanting" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelMultileg/confirmPlanting",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/airtravelMultileg/confirmPlanting', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelMultileg/confirmPlanting');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/airtravelMultileg/confirmPlanting');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelMultileg/confirmPlanting' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelMultileg/confirmPlanting' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/airtravelMultileg/confirmPlanting", payload, headers)

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

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

url = "{{baseUrl}}/airtravelMultileg/confirmPlanting"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/airtravelMultileg/confirmPlanting"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/airtravelMultileg/confirmPlanting")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/airtravelMultileg/confirmPlanting') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/airtravelMultileg/confirmPlanting \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/airtravelMultileg/confirmPlanting \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/airtravelMultileg/confirmPlanting
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelMultileg/confirmPlanting")! 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()
PATCH confirmTransaction (PATCH)
{{baseUrl}}/airtravelMultileg/confirmTransaction
BODY formUrlEncoded
confirmTransaction
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airtravelMultileg/confirmTransaction");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/airtravelMultileg/confirmTransaction" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/airtravelMultileg/confirmTransaction"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/airtravelMultileg/confirmTransaction"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/airtravelMultileg/confirmTransaction");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/airtravelMultileg/confirmTransaction"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/airtravelMultileg/confirmTransaction HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/airtravelMultileg/confirmTransaction")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/airtravelMultileg/confirmTransaction"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/airtravelMultileg/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/airtravelMultileg/confirmTransaction")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/airtravelMultileg/confirmTransaction');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/airtravelMultileg/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/airtravelMultileg/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/airtravelMultileg/confirmTransaction',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/airtravelMultileg/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/airtravelMultileg/confirmTransaction',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/airtravelMultileg/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/airtravelMultileg/confirmTransaction');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/airtravelMultileg/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/airtravelMultileg/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/airtravelMultileg/confirmTransaction"]
                                                       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}}/airtravelMultileg/confirmTransaction" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/airtravelMultileg/confirmTransaction",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/airtravelMultileg/confirmTransaction', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/airtravelMultileg/confirmTransaction');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/airtravelMultileg/confirmTransaction');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/airtravelMultileg/confirmTransaction' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/airtravelMultileg/confirmTransaction' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/airtravelMultileg/confirmTransaction", payload, headers)

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

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

url = "{{baseUrl}}/airtravelMultileg/confirmTransaction"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/airtravelMultileg/confirmTransaction"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/airtravelMultileg/confirmTransaction")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/airtravelMultileg/confirmTransaction') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/airtravelMultileg/confirmTransaction \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/airtravelMultileg/confirmTransaction \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/airtravelMultileg/confirmTransaction
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airtravelMultileg/confirmTransaction")! 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()
PATCH confirmCarbonOffset (1)
{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset
BODY formUrlEncoded
carbonOffset
contactEmail
contactFirstName
contactLastName
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/ecommerceDelivery/confirmCarbonOffset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/ecommerceDelivery/confirmCarbonOffset HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/ecommerceDelivery/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/ecommerceDelivery/confirmCarbonOffset');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/ecommerceDelivery/confirmCarbonOffset',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ecommerceDelivery/confirmCarbonOffset',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/ecommerceDelivery/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/ecommerceDelivery/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset"]
                                                       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}}/ecommerceDelivery/confirmCarbonOffset" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/ecommerceDelivery/confirmCarbonOffset", payload, headers)

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

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

url = "{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/ecommerceDelivery/confirmCarbonOffset') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/ecommerceDelivery/confirmCarbonOffset \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/ecommerceDelivery/confirmCarbonOffset \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/ecommerceDelivery/confirmCarbonOffset
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ecommerceDelivery/confirmCarbonOffset")! 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()
PATCH confirmPayment (1)
{{baseUrl}}/ecommerceDelivery/confirmPayment
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPayment
paymentID
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ecommerceDelivery/confirmPayment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/ecommerceDelivery/confirmPayment" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/ecommerceDelivery/confirmPayment"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/ecommerceDelivery/confirmPayment"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/ecommerceDelivery/confirmPayment");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/ecommerceDelivery/confirmPayment"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/ecommerceDelivery/confirmPayment HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/ecommerceDelivery/confirmPayment")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ecommerceDelivery/confirmPayment"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/ecommerceDelivery/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/ecommerceDelivery/confirmPayment")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/ecommerceDelivery/confirmPayment');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/ecommerceDelivery/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/ecommerceDelivery/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/ecommerceDelivery/confirmPayment',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ecommerceDelivery/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ecommerceDelivery/confirmPayment',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/ecommerceDelivery/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/ecommerceDelivery/confirmPayment');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/ecommerceDelivery/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/ecommerceDelivery/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ecommerceDelivery/confirmPayment"]
                                                       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}}/ecommerceDelivery/confirmPayment" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/ecommerceDelivery/confirmPayment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/ecommerceDelivery/confirmPayment', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/ecommerceDelivery/confirmPayment');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/ecommerceDelivery/confirmPayment');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ecommerceDelivery/confirmPayment' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ecommerceDelivery/confirmPayment' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/ecommerceDelivery/confirmPayment", payload, headers)

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

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

url = "{{baseUrl}}/ecommerceDelivery/confirmPayment"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/ecommerceDelivery/confirmPayment"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ecommerceDelivery/confirmPayment")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/ecommerceDelivery/confirmPayment') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/ecommerceDelivery/confirmPayment \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/ecommerceDelivery/confirmPayment \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/ecommerceDelivery/confirmPayment
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ecommerceDelivery/confirmPayment")! 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()
PATCH confirmPlanting (1)
{{baseUrl}}/ecommerceDelivery/confirmPlanting
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPlanting
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ecommerceDelivery/confirmPlanting");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/ecommerceDelivery/confirmPlanting" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/ecommerceDelivery/confirmPlanting"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/ecommerceDelivery/confirmPlanting"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/ecommerceDelivery/confirmPlanting");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/ecommerceDelivery/confirmPlanting"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/ecommerceDelivery/confirmPlanting HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/ecommerceDelivery/confirmPlanting")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ecommerceDelivery/confirmPlanting"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/ecommerceDelivery/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/ecommerceDelivery/confirmPlanting")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/ecommerceDelivery/confirmPlanting');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/ecommerceDelivery/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/ecommerceDelivery/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/ecommerceDelivery/confirmPlanting',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ecommerceDelivery/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ecommerceDelivery/confirmPlanting',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/ecommerceDelivery/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/ecommerceDelivery/confirmPlanting');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/ecommerceDelivery/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/ecommerceDelivery/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ecommerceDelivery/confirmPlanting"]
                                                       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}}/ecommerceDelivery/confirmPlanting" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/ecommerceDelivery/confirmPlanting",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/ecommerceDelivery/confirmPlanting', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/ecommerceDelivery/confirmPlanting');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/ecommerceDelivery/confirmPlanting');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ecommerceDelivery/confirmPlanting' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ecommerceDelivery/confirmPlanting' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/ecommerceDelivery/confirmPlanting", payload, headers)

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

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

url = "{{baseUrl}}/ecommerceDelivery/confirmPlanting"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/ecommerceDelivery/confirmPlanting"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ecommerceDelivery/confirmPlanting")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/ecommerceDelivery/confirmPlanting') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/ecommerceDelivery/confirmPlanting \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/ecommerceDelivery/confirmPlanting \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/ecommerceDelivery/confirmPlanting
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ecommerceDelivery/confirmPlanting")! 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()
PATCH confirmTransaction (1)
{{baseUrl}}/ecommerceDelivery/confirmTransaction
BODY formUrlEncoded
confirmTransaction
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ecommerceDelivery/confirmTransaction");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/ecommerceDelivery/confirmTransaction" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/ecommerceDelivery/confirmTransaction"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/ecommerceDelivery/confirmTransaction"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/ecommerceDelivery/confirmTransaction");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/ecommerceDelivery/confirmTransaction"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/ecommerceDelivery/confirmTransaction HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/ecommerceDelivery/confirmTransaction")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ecommerceDelivery/confirmTransaction"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/ecommerceDelivery/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/ecommerceDelivery/confirmTransaction")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/ecommerceDelivery/confirmTransaction');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/ecommerceDelivery/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/ecommerceDelivery/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/ecommerceDelivery/confirmTransaction',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ecommerceDelivery/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ecommerceDelivery/confirmTransaction',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/ecommerceDelivery/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/ecommerceDelivery/confirmTransaction');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/ecommerceDelivery/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/ecommerceDelivery/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ecommerceDelivery/confirmTransaction"]
                                                       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}}/ecommerceDelivery/confirmTransaction" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/ecommerceDelivery/confirmTransaction",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/ecommerceDelivery/confirmTransaction', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/ecommerceDelivery/confirmTransaction');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/ecommerceDelivery/confirmTransaction');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ecommerceDelivery/confirmTransaction' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ecommerceDelivery/confirmTransaction' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/ecommerceDelivery/confirmTransaction", payload, headers)

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

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

url = "{{baseUrl}}/ecommerceDelivery/confirmTransaction"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/ecommerceDelivery/confirmTransaction"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ecommerceDelivery/confirmTransaction")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/ecommerceDelivery/confirmTransaction') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/ecommerceDelivery/confirmTransaction \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/ecommerceDelivery/confirmTransaction \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/ecommerceDelivery/confirmTransaction
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ecommerceDelivery/confirmTransaction")! 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 ecommerceDelivery
{{baseUrl}}/ecommerceDelivery
HEADERS
Content-Type
BODY formUrlEncoded
apiKey_l1
apiKey_l2
destination_airport_code
destination_latitude
destination_longitude
origin_airport_code
origin_latitude
origin_longitude
volumetric_weight
waybill_type
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ecommerceDelivery");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/ecommerceDelivery" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/ecommerceDelivery"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/ecommerceDelivery"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/ecommerceDelivery");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

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

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
POST /baseUrl/ecommerceDelivery HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/ecommerceDelivery")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ecommerceDelivery"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/ecommerceDelivery")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/ecommerceDelivery")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/ecommerceDelivery');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ecommerceDelivery',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/ecommerceDelivery';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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}}/ecommerceDelivery',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ecommerceDelivery")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ecommerceDelivery',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/ecommerceDelivery',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/ecommerceDelivery');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/ecommerceDelivery',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/ecommerceDelivery';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ecommerceDelivery"]
                                                       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}}/ecommerceDelivery" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/ecommerceDelivery",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/ecommerceDelivery', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/ecommerceDelivery');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/ecommerceDelivery');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ecommerceDelivery' -Method POST -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ecommerceDelivery' -Method POST -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

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

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

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

url = "{{baseUrl}}/ecommerceDelivery"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

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

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/ecommerceDelivery') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/ecommerceDelivery \
  --header 'content-type: application/x-www-form-urlencoded'
http POST {{baseUrl}}/ecommerceDelivery \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/ecommerceDelivery
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ecommerceDelivery")! 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 requestApiKey
{{baseUrl}}/requestApiKey
BODY formUrlEncoded
apiKey_l1
apiKey_l2
email
password
userFirstName
userLastName
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/requestApiKey");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/requestApiKey" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/requestApiKey"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/requestApiKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/requestApiKey");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

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

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
POST /baseUrl/requestApiKey HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/requestApiKey")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/requestApiKey"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/requestApiKey")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/requestApiKey")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/requestApiKey');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/requestApiKey',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/requestApiKey';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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}}/requestApiKey',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/requestApiKey")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/requestApiKey',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/requestApiKey',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/requestApiKey');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/requestApiKey',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/requestApiKey';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/requestApiKey"]
                                                       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}}/requestApiKey" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/requestApiKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/requestApiKey', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/requestApiKey');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/requestApiKey');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/requestApiKey' -Method POST -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/requestApiKey' -Method POST -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

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

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

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

url = "{{baseUrl}}/requestApiKey"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

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

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/requestApiKey') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/requestApiKey \
  --header 'content-type: application/x-www-form-urlencoded'
http POST {{baseUrl}}/requestApiKey \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/requestApiKey
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/requestApiKey")! 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 RoadDistance
{{baseUrl}}/roadDistance
BODY formUrlEncoded
apiKey_l1
apiKey_l2
travel_distance
trip_end
trip_start
vehicle_make
vehicle_type
vehicle_year
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roadDistance");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/roadDistance" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/roadDistance"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/roadDistance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/roadDistance");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

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

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
POST /baseUrl/roadDistance HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/roadDistance")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/roadDistance"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/roadDistance")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/roadDistance")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/roadDistance');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/roadDistance',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/roadDistance';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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}}/roadDistance',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/roadDistance")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/roadDistance',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/roadDistance',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/roadDistance');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/roadDistance',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/roadDistance';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/roadDistance"]
                                                       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}}/roadDistance" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/roadDistance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/roadDistance', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/roadDistance');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/roadDistance');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/roadDistance' -Method POST -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/roadDistance' -Method POST -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

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

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

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

url = "{{baseUrl}}/roadDistance"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

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

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/roadDistance') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/roadDistance \
  --header 'content-type: application/x-www-form-urlencoded'
http POST {{baseUrl}}/roadDistance \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/roadDistance
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roadDistance")! 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()
PATCH confirmCarbonOffset (2)
{{baseUrl}}/roadDistance/confirmCarbonOffset
BODY formUrlEncoded
carbonOffset
contactEmail
contactFirstName
contactLastName
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roadDistance/confirmCarbonOffset");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/roadDistance/confirmCarbonOffset" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/roadDistance/confirmCarbonOffset"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/roadDistance/confirmCarbonOffset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/roadDistance/confirmCarbonOffset");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/roadDistance/confirmCarbonOffset"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/roadDistance/confirmCarbonOffset HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/roadDistance/confirmCarbonOffset")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/roadDistance/confirmCarbonOffset"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/roadDistance/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/roadDistance/confirmCarbonOffset")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/roadDistance/confirmCarbonOffset');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/roadDistance/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/roadDistance/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/roadDistance/confirmCarbonOffset',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/roadDistance/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/roadDistance/confirmCarbonOffset',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/roadDistance/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/roadDistance/confirmCarbonOffset');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/roadDistance/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/roadDistance/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/roadDistance/confirmCarbonOffset"]
                                                       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}}/roadDistance/confirmCarbonOffset" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/roadDistance/confirmCarbonOffset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/roadDistance/confirmCarbonOffset', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/roadDistance/confirmCarbonOffset');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/roadDistance/confirmCarbonOffset');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/roadDistance/confirmCarbonOffset' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/roadDistance/confirmCarbonOffset' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/roadDistance/confirmCarbonOffset", payload, headers)

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

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

url = "{{baseUrl}}/roadDistance/confirmCarbonOffset"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/roadDistance/confirmCarbonOffset"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/roadDistance/confirmCarbonOffset")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/roadDistance/confirmCarbonOffset') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/roadDistance/confirmCarbonOffset \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/roadDistance/confirmCarbonOffset \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/roadDistance/confirmCarbonOffset
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roadDistance/confirmCarbonOffset")! 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()
PATCH confirmPayment (2)
{{baseUrl}}/roadDistance/confirmPayment
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPayment
paymentID
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roadDistance/confirmPayment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/roadDistance/confirmPayment" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/roadDistance/confirmPayment"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/roadDistance/confirmPayment"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/roadDistance/confirmPayment");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/roadDistance/confirmPayment"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/roadDistance/confirmPayment HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/roadDistance/confirmPayment")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/roadDistance/confirmPayment"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/roadDistance/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/roadDistance/confirmPayment")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/roadDistance/confirmPayment');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/roadDistance/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/roadDistance/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/roadDistance/confirmPayment',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/roadDistance/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/roadDistance/confirmPayment',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/roadDistance/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/roadDistance/confirmPayment');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/roadDistance/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/roadDistance/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/roadDistance/confirmPayment"]
                                                       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}}/roadDistance/confirmPayment" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/roadDistance/confirmPayment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/roadDistance/confirmPayment', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/roadDistance/confirmPayment');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/roadDistance/confirmPayment');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/roadDistance/confirmPayment' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/roadDistance/confirmPayment' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/roadDistance/confirmPayment", payload, headers)

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

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

url = "{{baseUrl}}/roadDistance/confirmPayment"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/roadDistance/confirmPayment"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/roadDistance/confirmPayment")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/roadDistance/confirmPayment') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/roadDistance/confirmPayment \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/roadDistance/confirmPayment \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/roadDistance/confirmPayment
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roadDistance/confirmPayment")! 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()
PATCH confirmPlanting (2)
{{baseUrl}}/roadDistance/confirmPlanting
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPlanting
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roadDistance/confirmPlanting");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/roadDistance/confirmPlanting" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/roadDistance/confirmPlanting"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/roadDistance/confirmPlanting"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/roadDistance/confirmPlanting");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/roadDistance/confirmPlanting"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/roadDistance/confirmPlanting HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/roadDistance/confirmPlanting")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/roadDistance/confirmPlanting"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/roadDistance/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/roadDistance/confirmPlanting")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/roadDistance/confirmPlanting');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/roadDistance/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/roadDistance/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/roadDistance/confirmPlanting',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/roadDistance/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/roadDistance/confirmPlanting',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/roadDistance/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/roadDistance/confirmPlanting');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/roadDistance/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/roadDistance/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/roadDistance/confirmPlanting"]
                                                       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}}/roadDistance/confirmPlanting" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/roadDistance/confirmPlanting",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/roadDistance/confirmPlanting', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/roadDistance/confirmPlanting');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/roadDistance/confirmPlanting');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/roadDistance/confirmPlanting' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/roadDistance/confirmPlanting' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/roadDistance/confirmPlanting", payload, headers)

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

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

url = "{{baseUrl}}/roadDistance/confirmPlanting"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/roadDistance/confirmPlanting"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/roadDistance/confirmPlanting")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/roadDistance/confirmPlanting') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/roadDistance/confirmPlanting \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/roadDistance/confirmPlanting \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/roadDistance/confirmPlanting
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roadDistance/confirmPlanting")! 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()
PATCH confirmTransaction (2)
{{baseUrl}}/roadDistance/confirmTransaction
BODY formUrlEncoded
confirmTransaction
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roadDistance/confirmTransaction");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/roadDistance/confirmTransaction" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/roadDistance/confirmTransaction"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/roadDistance/confirmTransaction"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/roadDistance/confirmTransaction");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/roadDistance/confirmTransaction"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/roadDistance/confirmTransaction HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/roadDistance/confirmTransaction")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/roadDistance/confirmTransaction"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/roadDistance/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/roadDistance/confirmTransaction")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/roadDistance/confirmTransaction');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/roadDistance/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/roadDistance/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/roadDistance/confirmTransaction',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/roadDistance/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/roadDistance/confirmTransaction',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/roadDistance/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/roadDistance/confirmTransaction');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/roadDistance/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/roadDistance/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/roadDistance/confirmTransaction"]
                                                       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}}/roadDistance/confirmTransaction" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/roadDistance/confirmTransaction",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/roadDistance/confirmTransaction', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/roadDistance/confirmTransaction');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/roadDistance/confirmTransaction');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/roadDistance/confirmTransaction' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/roadDistance/confirmTransaction' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/roadDistance/confirmTransaction", payload, headers)

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

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

url = "{{baseUrl}}/roadDistance/confirmTransaction"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/roadDistance/confirmTransaction"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/roadDistance/confirmTransaction")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/roadDistance/confirmTransaction') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/roadDistance/confirmTransaction \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/roadDistance/confirmTransaction \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/roadDistance/confirmTransaction
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roadDistance/confirmTransaction")! 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()
PATCH confirmCarbonOffset (3)
{{baseUrl}}/urbanDelivery/confirmCarbonOffset
BODY formUrlEncoded
carbonOffset
contactEmail
contactFirstName
contactLastName
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/urbanDelivery/confirmCarbonOffset");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/urbanDelivery/confirmCarbonOffset" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/urbanDelivery/confirmCarbonOffset"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/urbanDelivery/confirmCarbonOffset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/urbanDelivery/confirmCarbonOffset");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/urbanDelivery/confirmCarbonOffset"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/urbanDelivery/confirmCarbonOffset HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/urbanDelivery/confirmCarbonOffset")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/urbanDelivery/confirmCarbonOffset"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/urbanDelivery/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/urbanDelivery/confirmCarbonOffset")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/urbanDelivery/confirmCarbonOffset');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/urbanDelivery/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/urbanDelivery/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/urbanDelivery/confirmCarbonOffset',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/urbanDelivery/confirmCarbonOffset")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/urbanDelivery/confirmCarbonOffset',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/urbanDelivery/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/urbanDelivery/confirmCarbonOffset');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/urbanDelivery/confirmCarbonOffset',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/urbanDelivery/confirmCarbonOffset';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/urbanDelivery/confirmCarbonOffset"]
                                                       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}}/urbanDelivery/confirmCarbonOffset" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/urbanDelivery/confirmCarbonOffset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/urbanDelivery/confirmCarbonOffset', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/urbanDelivery/confirmCarbonOffset');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/urbanDelivery/confirmCarbonOffset');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/urbanDelivery/confirmCarbonOffset' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/urbanDelivery/confirmCarbonOffset' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/urbanDelivery/confirmCarbonOffset", payload, headers)

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

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

url = "{{baseUrl}}/urbanDelivery/confirmCarbonOffset"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/urbanDelivery/confirmCarbonOffset"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/urbanDelivery/confirmCarbonOffset")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/urbanDelivery/confirmCarbonOffset') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/urbanDelivery/confirmCarbonOffset \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/urbanDelivery/confirmCarbonOffset \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/urbanDelivery/confirmCarbonOffset
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/urbanDelivery/confirmCarbonOffset")! 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()
PATCH confirmPayment (3)
{{baseUrl}}/urbanDelivery/confirmPayment
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPayment
paymentID
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/urbanDelivery/confirmPayment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/urbanDelivery/confirmPayment" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/urbanDelivery/confirmPayment"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/urbanDelivery/confirmPayment"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/urbanDelivery/confirmPayment");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/urbanDelivery/confirmPayment"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/urbanDelivery/confirmPayment HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/urbanDelivery/confirmPayment")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/urbanDelivery/confirmPayment"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/urbanDelivery/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/urbanDelivery/confirmPayment")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/urbanDelivery/confirmPayment');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/urbanDelivery/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/urbanDelivery/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/urbanDelivery/confirmPayment',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/urbanDelivery/confirmPayment")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/urbanDelivery/confirmPayment',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/urbanDelivery/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/urbanDelivery/confirmPayment');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/urbanDelivery/confirmPayment',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/urbanDelivery/confirmPayment';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/urbanDelivery/confirmPayment"]
                                                       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}}/urbanDelivery/confirmPayment" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/urbanDelivery/confirmPayment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/urbanDelivery/confirmPayment', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/urbanDelivery/confirmPayment');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/urbanDelivery/confirmPayment');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/urbanDelivery/confirmPayment' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/urbanDelivery/confirmPayment' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/urbanDelivery/confirmPayment", payload, headers)

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

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

url = "{{baseUrl}}/urbanDelivery/confirmPayment"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/urbanDelivery/confirmPayment"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/urbanDelivery/confirmPayment")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/urbanDelivery/confirmPayment') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/urbanDelivery/confirmPayment \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/urbanDelivery/confirmPayment \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/urbanDelivery/confirmPayment
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/urbanDelivery/confirmPayment")! 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()
PATCH confirmPlanting (3)
{{baseUrl}}/urbanDelivery/confirmPlanting
BODY formUrlEncoded
apiKey_l1
apiKey_l2
confirmPlanting
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/urbanDelivery/confirmPlanting");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/urbanDelivery/confirmPlanting" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/urbanDelivery/confirmPlanting"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/urbanDelivery/confirmPlanting"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/urbanDelivery/confirmPlanting");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/urbanDelivery/confirmPlanting"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/urbanDelivery/confirmPlanting HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/urbanDelivery/confirmPlanting")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/urbanDelivery/confirmPlanting"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/urbanDelivery/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/urbanDelivery/confirmPlanting")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/urbanDelivery/confirmPlanting');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/urbanDelivery/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/urbanDelivery/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/urbanDelivery/confirmPlanting',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/urbanDelivery/confirmPlanting")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/urbanDelivery/confirmPlanting',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/urbanDelivery/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/urbanDelivery/confirmPlanting');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/urbanDelivery/confirmPlanting',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/urbanDelivery/confirmPlanting';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/urbanDelivery/confirmPlanting"]
                                                       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}}/urbanDelivery/confirmPlanting" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/urbanDelivery/confirmPlanting",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/urbanDelivery/confirmPlanting', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/urbanDelivery/confirmPlanting');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/urbanDelivery/confirmPlanting');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/urbanDelivery/confirmPlanting' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/urbanDelivery/confirmPlanting' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/urbanDelivery/confirmPlanting", payload, headers)

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

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

url = "{{baseUrl}}/urbanDelivery/confirmPlanting"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/urbanDelivery/confirmPlanting"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/urbanDelivery/confirmPlanting")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/urbanDelivery/confirmPlanting') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/urbanDelivery/confirmPlanting \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/urbanDelivery/confirmPlanting \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/urbanDelivery/confirmPlanting
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/urbanDelivery/confirmPlanting")! 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()
PATCH confirmTransaction (3)
{{baseUrl}}/urbanDelivery/confirmTransaction
BODY formUrlEncoded
confirmTransaction
transaction_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/urbanDelivery/confirmTransaction");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/urbanDelivery/confirmTransaction" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/urbanDelivery/confirmTransaction"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/urbanDelivery/confirmTransaction"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/urbanDelivery/confirmTransaction");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/urbanDelivery/confirmTransaction"

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PATCH /baseUrl/urbanDelivery/confirmTransaction HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/urbanDelivery/confirmTransaction")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/urbanDelivery/confirmTransaction"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/urbanDelivery/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/urbanDelivery/confirmTransaction")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/urbanDelivery/confirmTransaction');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/urbanDelivery/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/urbanDelivery/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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}}/urbanDelivery/confirmTransaction',
  method: 'PATCH',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/urbanDelivery/confirmTransaction")
  .patch(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/urbanDelivery/confirmTransaction',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/urbanDelivery/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/urbanDelivery/confirmTransaction');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/urbanDelivery/confirmTransaction',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/urbanDelivery/confirmTransaction';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/urbanDelivery/confirmTransaction"]
                                                       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}}/urbanDelivery/confirmTransaction" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/urbanDelivery/confirmTransaction",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PATCH', '{{baseUrl}}/urbanDelivery/confirmTransaction', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/urbanDelivery/confirmTransaction');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/urbanDelivery/confirmTransaction');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/urbanDelivery/confirmTransaction' -Method PATCH -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/urbanDelivery/confirmTransaction' -Method PATCH -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PATCH", "/baseUrl/urbanDelivery/confirmTransaction", payload, headers)

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

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

url = "{{baseUrl}}/urbanDelivery/confirmTransaction"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/urbanDelivery/confirmTransaction"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/urbanDelivery/confirmTransaction")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.patch('/baseUrl/urbanDelivery/confirmTransaction') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/urbanDelivery/confirmTransaction \
  --header 'content-type: application/x-www-form-urlencoded'
http PATCH {{baseUrl}}/urbanDelivery/confirmTransaction \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method PATCH \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/urbanDelivery/confirmTransaction
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/urbanDelivery/confirmTransaction")! 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 urbanDelivery
{{baseUrl}}/urbanDelivery
BODY formUrlEncoded
apiKey_l1
apiKey_l2
destination_latitude
destination_longitude
item_count
origin_latitude
origin_longitude
vehicle_type
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/urbanDelivery");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/urbanDelivery" {:headers {:content-type "application/x-www-form-urlencoded"}})
require "http/client"

url = "{{baseUrl}}/urbanDelivery"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}

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}}/urbanDelivery"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/urbanDelivery");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);
package main

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

func main() {

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

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
POST /baseUrl/urbanDelivery HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/urbanDelivery")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/urbanDelivery"))
    .header("content-type", "application/x-www-form-urlencoded")
    .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}}/urbanDelivery")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/urbanDelivery")
  .header("content-type", "application/x-www-form-urlencoded")
  .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}}/urbanDelivery');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/urbanDelivery',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/urbanDelivery';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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}}/urbanDelivery',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/urbanDelivery")
  .post(null)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/urbanDelivery',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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}}/urbanDelivery',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/urbanDelivery');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

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}}/urbanDelivery',
  headers: {'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/urbanDelivery';
const options = {method: 'POST', headers: {'content-type': 'application/x-www-form-urlencoded'}};

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/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/urbanDelivery"]
                                                       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}}/urbanDelivery" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/urbanDelivery",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/urbanDelivery', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/urbanDelivery');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/urbanDelivery');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/urbanDelivery' -Method POST -Headers $headers
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/urbanDelivery' -Method POST -Headers $headers
import http.client

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

payload = ""

headers = { 'content-type': "application/x-www-form-urlencoded" }

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

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

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

url = "{{baseUrl}}/urbanDelivery"

payload = ""
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

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

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/urbanDelivery') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".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}}/urbanDelivery \
  --header 'content-type: application/x-www-form-urlencoded'
http POST {{baseUrl}}/urbanDelivery \
  content-type:application/x-www-form-urlencoded
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/urbanDelivery
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

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