Amazon Connect Customer Profilesv2020-08-15

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles/keys");

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  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName/profiles/keys" {:content-type :json
                                                                              :form-params {:ProfileId ""
                                                                                            :KeyName ""
                                                                                            :Values []}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles/keys"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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}}/domains/:DomainName/profiles/keys"),
    Content = new StringContent("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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}}/domains/:DomainName/profiles/keys");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles/keys"

	payload := strings.NewReader("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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/domains/:DomainName/profiles/keys HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/profiles/keys")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles/keys"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/keys")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/profiles/keys")
  .header("content-type", "application/json")
  .body("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}")
  .asString();

const data = JSON.stringify({
  ProfileId: '',
  KeyName: '',
  Values: []
});

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

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

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/profiles/keys');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/keys',
  headers: {'content-type': 'application/json'},
  data: {ProfileId: '', KeyName: '', Values: []}
};

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

const url = '{{baseUrl}}/domains/:DomainName/profiles/keys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":"","KeyName":"","Values":[]}'
};

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}}/domains/:DomainName/profiles/keys',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProfileId": "",\n  "KeyName": "",\n  "Values": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/keys")
  .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/domains/:DomainName/profiles/keys',
  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({ProfileId: '', KeyName: '', Values: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/keys',
  headers: {'content-type': 'application/json'},
  body: {ProfileId: '', KeyName: '', Values: []},
  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}}/domains/:DomainName/profiles/keys');

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

req.type('json');
req.send({
  ProfileId: '',
  KeyName: '',
  Values: []
});

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}}/domains/:DomainName/profiles/keys',
  headers: {'content-type': 'application/json'},
  data: {ProfileId: '', KeyName: '', Values: []}
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/profiles/keys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":"","KeyName":"","Values":[]}'
};

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 = @{ @"ProfileId": @"",
                              @"KeyName": @"",
                              @"Values": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles/keys"]
                                                       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}}/domains/:DomainName/profiles/keys" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}" in

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

 "{{baseUrl}}/domains/:DomainName/profiles/keys",
  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([
    'ProfileId' => '',
    'KeyName' => '',
    'Values' => [
        
    ]
  ]),
  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}}/domains/:DomainName/profiles/keys', [
  'body' => '{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles/keys');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProfileId' => '',
  'KeyName' => '',
  'Values' => [
    
  ]
]));

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

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

append(json_encode([
  'ProfileId' => '',
  'KeyName' => '',
  'Values' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles/keys');
$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}}/domains/:DomainName/profiles/keys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles/keys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}'

import http.client

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

payload = "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}"

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

conn.request("POST", "/baseUrl/domains/:DomainName/profiles/keys", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles/keys"

payload = {
    "ProfileId": "",
    "KeyName": "",
    "Values": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles/keys"

payload <- "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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}}/domains/:DomainName/profiles/keys")

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  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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/domains/:DomainName/profiles/keys') do |req|
  req.body = "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ProfileId": "",
        "KeyName": "",
        "Values": ()
    });

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

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

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

    dbg!(results);
}

echo '{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/profiles/keys \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProfileId": "",\n  "KeyName": "",\n  "Values": []\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles/keys

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ProfileId": "",
  "KeyName": "",
  "Values": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName");

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  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName" {:content-type :json
                                                                :form-params {:DefaultExpirationDays 0
                                                                              :DefaultEncryptionKey ""
                                                                              :DeadLetterQueueUrl ""
                                                                              :Matching {:Enabled ""
                                                                                         :JobSchedule ""
                                                                                         :AutoMerging ""
                                                                                         :ExportingConfig ""}
                                                                              :Tags {}}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\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}}/domains/:DomainName"),
    Content = new StringContent("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\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}}/domains/:DomainName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName"

	payload := strings.NewReader("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\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/domains/:DomainName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 216

{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\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  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName")
  .header("content-type", "application/json")
  .body("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  DefaultExpirationDays: 0,
  DefaultEncryptionKey: '',
  DeadLetterQueueUrl: '',
  Matching: {
    Enabled: '',
    JobSchedule: '',
    AutoMerging: '',
    ExportingConfig: ''
  },
  Tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultExpirationDays: 0,
    DefaultEncryptionKey: '',
    DeadLetterQueueUrl: '',
    Matching: {Enabled: '', JobSchedule: '', AutoMerging: '', ExportingConfig: ''},
    Tags: {}
  }
};

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

const url = '{{baseUrl}}/domains/:DomainName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultExpirationDays":0,"DefaultEncryptionKey":"","DeadLetterQueueUrl":"","Matching":{"Enabled":"","JobSchedule":"","AutoMerging":"","ExportingConfig":""},"Tags":{}}'
};

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}}/domains/:DomainName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DefaultExpirationDays": 0,\n  "DefaultEncryptionKey": "",\n  "DeadLetterQueueUrl": "",\n  "Matching": {\n    "Enabled": "",\n    "JobSchedule": "",\n    "AutoMerging": "",\n    "ExportingConfig": ""\n  },\n  "Tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName")
  .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/domains/:DomainName',
  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({
  DefaultExpirationDays: 0,
  DefaultEncryptionKey: '',
  DeadLetterQueueUrl: '',
  Matching: {Enabled: '', JobSchedule: '', AutoMerging: '', ExportingConfig: ''},
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName',
  headers: {'content-type': 'application/json'},
  body: {
    DefaultExpirationDays: 0,
    DefaultEncryptionKey: '',
    DeadLetterQueueUrl: '',
    Matching: {Enabled: '', JobSchedule: '', AutoMerging: '', ExportingConfig: ''},
    Tags: {}
  },
  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}}/domains/:DomainName');

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

req.type('json');
req.send({
  DefaultExpirationDays: 0,
  DefaultEncryptionKey: '',
  DeadLetterQueueUrl: '',
  Matching: {
    Enabled: '',
    JobSchedule: '',
    AutoMerging: '',
    ExportingConfig: ''
  },
  Tags: {}
});

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}}/domains/:DomainName',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultExpirationDays: 0,
    DefaultEncryptionKey: '',
    DeadLetterQueueUrl: '',
    Matching: {Enabled: '', JobSchedule: '', AutoMerging: '', ExportingConfig: ''},
    Tags: {}
  }
};

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

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

const url = '{{baseUrl}}/domains/:DomainName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultExpirationDays":0,"DefaultEncryptionKey":"","DeadLetterQueueUrl":"","Matching":{"Enabled":"","JobSchedule":"","AutoMerging":"","ExportingConfig":""},"Tags":{}}'
};

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 = @{ @"DefaultExpirationDays": @0,
                              @"DefaultEncryptionKey": @"",
                              @"DeadLetterQueueUrl": @"",
                              @"Matching": @{ @"Enabled": @"", @"JobSchedule": @"", @"AutoMerging": @"", @"ExportingConfig": @"" },
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName"]
                                                       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}}/domains/:DomainName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/domains/:DomainName",
  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([
    'DefaultExpirationDays' => 0,
    'DefaultEncryptionKey' => '',
    'DeadLetterQueueUrl' => '',
    'Matching' => [
        'Enabled' => '',
        'JobSchedule' => '',
        'AutoMerging' => '',
        'ExportingConfig' => ''
    ],
    'Tags' => [
        
    ]
  ]),
  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}}/domains/:DomainName', [
  'body' => '{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DefaultExpirationDays' => 0,
  'DefaultEncryptionKey' => '',
  'DeadLetterQueueUrl' => '',
  'Matching' => [
    'Enabled' => '',
    'JobSchedule' => '',
    'AutoMerging' => '',
    'ExportingConfig' => ''
  ],
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'DefaultExpirationDays' => 0,
  'DefaultEncryptionKey' => '',
  'DeadLetterQueueUrl' => '',
  'Matching' => [
    'Enabled' => '',
    'JobSchedule' => '',
    'AutoMerging' => '',
    'ExportingConfig' => ''
  ],
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName');
$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}}/domains/:DomainName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}"

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

conn.request("POST", "/baseUrl/domains/:DomainName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName"

payload = {
    "DefaultExpirationDays": 0,
    "DefaultEncryptionKey": "",
    "DeadLetterQueueUrl": "",
    "Matching": {
        "Enabled": "",
        "JobSchedule": "",
        "AutoMerging": "",
        "ExportingConfig": ""
    },
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName"

payload <- "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\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}}/domains/:DomainName")

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  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\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/domains/:DomainName') do |req|
  req.body = "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "DefaultExpirationDays": 0,
        "DefaultEncryptionKey": "",
        "DeadLetterQueueUrl": "",
        "Matching": json!({
            "Enabled": "",
            "JobSchedule": "",
            "AutoMerging": "",
            "ExportingConfig": ""
        }),
        "Tags": json!({})
    });

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

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

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

    dbg!(results);
}

echo '{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}' |  \
  http POST {{baseUrl}}/domains/:DomainName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DefaultExpirationDays": 0,\n  "DefaultEncryptionKey": "",\n  "DeadLetterQueueUrl": "",\n  "Matching": {\n    "Enabled": "",\n    "JobSchedule": "",\n    "AutoMerging": "",\n    "ExportingConfig": ""\n  },\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": [
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  ],
  "Tags": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/workflows/integrations");

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  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName/workflows/integrations" {:content-type :json
                                                                                       :form-params {:WorkflowType ""
                                                                                                     :IntegrationConfig {:AppflowIntegration ""}
                                                                                                     :ObjectTypeName ""
                                                                                                     :RoleArn ""
                                                                                                     :Tags {}}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/workflows/integrations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\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}}/domains/:DomainName/workflows/integrations"),
    Content = new StringContent("{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\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}}/domains/:DomainName/workflows/integrations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/workflows/integrations"

	payload := strings.NewReader("{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\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/domains/:DomainName/workflows/integrations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 138

{
  "WorkflowType": "",
  "IntegrationConfig": {
    "AppflowIntegration": ""
  },
  "ObjectTypeName": "",
  "RoleArn": "",
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/workflows/integrations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/workflows/integrations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\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  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows/integrations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/workflows/integrations")
  .header("content-type", "application/json")
  .body("{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  WorkflowType: '',
  IntegrationConfig: {
    AppflowIntegration: ''
  },
  ObjectTypeName: '',
  RoleArn: '',
  Tags: {}
});

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

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

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/workflows/integrations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/workflows/integrations',
  headers: {'content-type': 'application/json'},
  data: {
    WorkflowType: '',
    IntegrationConfig: {AppflowIntegration: ''},
    ObjectTypeName: '',
    RoleArn: '',
    Tags: {}
  }
};

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

const url = '{{baseUrl}}/domains/:DomainName/workflows/integrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"WorkflowType":"","IntegrationConfig":{"AppflowIntegration":""},"ObjectTypeName":"","RoleArn":"","Tags":{}}'
};

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}}/domains/:DomainName/workflows/integrations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WorkflowType": "",\n  "IntegrationConfig": {\n    "AppflowIntegration": ""\n  },\n  "ObjectTypeName": "",\n  "RoleArn": "",\n  "Tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows/integrations")
  .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/domains/:DomainName/workflows/integrations',
  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({
  WorkflowType: '',
  IntegrationConfig: {AppflowIntegration: ''},
  ObjectTypeName: '',
  RoleArn: '',
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/workflows/integrations',
  headers: {'content-type': 'application/json'},
  body: {
    WorkflowType: '',
    IntegrationConfig: {AppflowIntegration: ''},
    ObjectTypeName: '',
    RoleArn: '',
    Tags: {}
  },
  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}}/domains/:DomainName/workflows/integrations');

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

req.type('json');
req.send({
  WorkflowType: '',
  IntegrationConfig: {
    AppflowIntegration: ''
  },
  ObjectTypeName: '',
  RoleArn: '',
  Tags: {}
});

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}}/domains/:DomainName/workflows/integrations',
  headers: {'content-type': 'application/json'},
  data: {
    WorkflowType: '',
    IntegrationConfig: {AppflowIntegration: ''},
    ObjectTypeName: '',
    RoleArn: '',
    Tags: {}
  }
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/workflows/integrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"WorkflowType":"","IntegrationConfig":{"AppflowIntegration":""},"ObjectTypeName":"","RoleArn":"","Tags":{}}'
};

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 = @{ @"WorkflowType": @"",
                              @"IntegrationConfig": @{ @"AppflowIntegration": @"" },
                              @"ObjectTypeName": @"",
                              @"RoleArn": @"",
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/workflows/integrations"]
                                                       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}}/domains/:DomainName/workflows/integrations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/domains/:DomainName/workflows/integrations",
  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([
    'WorkflowType' => '',
    'IntegrationConfig' => [
        'AppflowIntegration' => ''
    ],
    'ObjectTypeName' => '',
    'RoleArn' => '',
    'Tags' => [
        
    ]
  ]),
  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}}/domains/:DomainName/workflows/integrations', [
  'body' => '{
  "WorkflowType": "",
  "IntegrationConfig": {
    "AppflowIntegration": ""
  },
  "ObjectTypeName": "",
  "RoleArn": "",
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/workflows/integrations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WorkflowType' => '',
  'IntegrationConfig' => [
    'AppflowIntegration' => ''
  ],
  'ObjectTypeName' => '',
  'RoleArn' => '',
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'WorkflowType' => '',
  'IntegrationConfig' => [
    'AppflowIntegration' => ''
  ],
  'ObjectTypeName' => '',
  'RoleArn' => '',
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/workflows/integrations');
$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}}/domains/:DomainName/workflows/integrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowType": "",
  "IntegrationConfig": {
    "AppflowIntegration": ""
  },
  "ObjectTypeName": "",
  "RoleArn": "",
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/workflows/integrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowType": "",
  "IntegrationConfig": {
    "AppflowIntegration": ""
  },
  "ObjectTypeName": "",
  "RoleArn": "",
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\n}"

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

conn.request("POST", "/baseUrl/domains/:DomainName/workflows/integrations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/workflows/integrations"

payload = {
    "WorkflowType": "",
    "IntegrationConfig": { "AppflowIntegration": "" },
    "ObjectTypeName": "",
    "RoleArn": "",
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/workflows/integrations"

payload <- "{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\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}}/domains/:DomainName/workflows/integrations")

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  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\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/domains/:DomainName/workflows/integrations') do |req|
  req.body = "{\n  \"WorkflowType\": \"\",\n  \"IntegrationConfig\": {\n    \"AppflowIntegration\": \"\"\n  },\n  \"ObjectTypeName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "WorkflowType": "",
        "IntegrationConfig": json!({"AppflowIntegration": ""}),
        "ObjectTypeName": "",
        "RoleArn": "",
        "Tags": json!({})
    });

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

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

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

    dbg!(results);
}

echo '{
  "WorkflowType": "",
  "IntegrationConfig": {
    "AppflowIntegration": ""
  },
  "ObjectTypeName": "",
  "RoleArn": "",
  "Tags": {}
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/workflows/integrations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "WorkflowType": "",\n  "IntegrationConfig": {\n    "AppflowIntegration": ""\n  },\n  "ObjectTypeName": "",\n  "RoleArn": "",\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/workflows/integrations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "WorkflowType": "",
  "IntegrationConfig": ["AppflowIntegration": ""],
  "ObjectTypeName": "",
  "RoleArn": "",
  "Tags": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles");

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  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName/profiles" {:content-type :json
                                                                         :form-params {:AccountNumber ""
                                                                                       :AdditionalInformation ""
                                                                                       :PartyType ""
                                                                                       :BusinessName ""
                                                                                       :FirstName ""
                                                                                       :MiddleName ""
                                                                                       :LastName ""
                                                                                       :BirthDate ""
                                                                                       :Gender ""
                                                                                       :PhoneNumber ""
                                                                                       :MobilePhoneNumber ""
                                                                                       :HomePhoneNumber ""
                                                                                       :BusinessPhoneNumber ""
                                                                                       :EmailAddress ""
                                                                                       :PersonalEmailAddress ""
                                                                                       :BusinessEmailAddress ""
                                                                                       :Address {:Address1 ""
                                                                                                 :Address2 ""
                                                                                                 :Address3 ""
                                                                                                 :Address4 ""
                                                                                                 :City ""
                                                                                                 :County ""
                                                                                                 :State ""
                                                                                                 :Province ""
                                                                                                 :Country ""
                                                                                                 :PostalCode ""}
                                                                                       :ShippingAddress {:Address1 ""
                                                                                                         :Address2 ""
                                                                                                         :Address3 ""
                                                                                                         :Address4 ""
                                                                                                         :City ""
                                                                                                         :County ""
                                                                                                         :State ""
                                                                                                         :Province ""
                                                                                                         :Country ""
                                                                                                         :PostalCode ""}
                                                                                       :MailingAddress {:Address1 ""
                                                                                                        :Address2 ""
                                                                                                        :Address3 ""
                                                                                                        :Address4 ""
                                                                                                        :City ""
                                                                                                        :County ""
                                                                                                        :State ""
                                                                                                        :Province ""
                                                                                                        :Country ""
                                                                                                        :PostalCode ""}
                                                                                       :BillingAddress {:Address1 ""
                                                                                                        :Address2 ""
                                                                                                        :Address3 ""
                                                                                                        :Address4 ""
                                                                                                        :City ""
                                                                                                        :County ""
                                                                                                        :State ""
                                                                                                        :Province ""
                                                                                                        :Country ""
                                                                                                        :PostalCode ""}
                                                                                       :Attributes {}
                                                                                       :PartyTypeString ""
                                                                                       :GenderString ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\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}}/domains/:DomainName/profiles"),
    Content = new StringContent("{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\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}}/domains/:DomainName/profiles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles"

	payload := strings.NewReader("{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\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/domains/:DomainName/profiles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1306

{
  "AccountNumber": "",
  "AdditionalInformation": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/profiles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\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  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/profiles")
  .header("content-type", "application/json")
  .body("{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccountNumber: '',
  AdditionalInformation: '',
  PartyType: '',
  BusinessName: '',
  FirstName: '',
  MiddleName: '',
  LastName: '',
  BirthDate: '',
  Gender: '',
  PhoneNumber: '',
  MobilePhoneNumber: '',
  HomePhoneNumber: '',
  BusinessPhoneNumber: '',
  EmailAddress: '',
  PersonalEmailAddress: '',
  BusinessEmailAddress: '',
  Address: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  ShippingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  MailingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  BillingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  Attributes: {},
  PartyTypeString: '',
  GenderString: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/profiles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles',
  headers: {'content-type': 'application/json'},
  data: {
    AccountNumber: '',
    AdditionalInformation: '',
    PartyType: '',
    BusinessName: '',
    FirstName: '',
    MiddleName: '',
    LastName: '',
    BirthDate: '',
    Gender: '',
    PhoneNumber: '',
    MobilePhoneNumber: '',
    HomePhoneNumber: '',
    BusinessPhoneNumber: '',
    EmailAddress: '',
    PersonalEmailAddress: '',
    BusinessEmailAddress: '',
    Address: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    ShippingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    MailingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    BillingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    Attributes: {},
    PartyTypeString: '',
    GenderString: ''
  }
};

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

const url = '{{baseUrl}}/domains/:DomainName/profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccountNumber":"","AdditionalInformation":"","PartyType":"","BusinessName":"","FirstName":"","MiddleName":"","LastName":"","BirthDate":"","Gender":"","PhoneNumber":"","MobilePhoneNumber":"","HomePhoneNumber":"","BusinessPhoneNumber":"","EmailAddress":"","PersonalEmailAddress":"","BusinessEmailAddress":"","Address":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"ShippingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"MailingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"BillingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"Attributes":{},"PartyTypeString":"","GenderString":""}'
};

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}}/domains/:DomainName/profiles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccountNumber": "",\n  "AdditionalInformation": "",\n  "PartyType": "",\n  "BusinessName": "",\n  "FirstName": "",\n  "MiddleName": "",\n  "LastName": "",\n  "BirthDate": "",\n  "Gender": "",\n  "PhoneNumber": "",\n  "MobilePhoneNumber": "",\n  "HomePhoneNumber": "",\n  "BusinessPhoneNumber": "",\n  "EmailAddress": "",\n  "PersonalEmailAddress": "",\n  "BusinessEmailAddress": "",\n  "Address": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "ShippingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "MailingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "BillingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "Attributes": {},\n  "PartyTypeString": "",\n  "GenderString": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles")
  .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/domains/:DomainName/profiles',
  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({
  AccountNumber: '',
  AdditionalInformation: '',
  PartyType: '',
  BusinessName: '',
  FirstName: '',
  MiddleName: '',
  LastName: '',
  BirthDate: '',
  Gender: '',
  PhoneNumber: '',
  MobilePhoneNumber: '',
  HomePhoneNumber: '',
  BusinessPhoneNumber: '',
  EmailAddress: '',
  PersonalEmailAddress: '',
  BusinessEmailAddress: '',
  Address: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  ShippingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  MailingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  BillingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  Attributes: {},
  PartyTypeString: '',
  GenderString: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles',
  headers: {'content-type': 'application/json'},
  body: {
    AccountNumber: '',
    AdditionalInformation: '',
    PartyType: '',
    BusinessName: '',
    FirstName: '',
    MiddleName: '',
    LastName: '',
    BirthDate: '',
    Gender: '',
    PhoneNumber: '',
    MobilePhoneNumber: '',
    HomePhoneNumber: '',
    BusinessPhoneNumber: '',
    EmailAddress: '',
    PersonalEmailAddress: '',
    BusinessEmailAddress: '',
    Address: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    ShippingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    MailingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    BillingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    Attributes: {},
    PartyTypeString: '',
    GenderString: ''
  },
  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}}/domains/:DomainName/profiles');

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

req.type('json');
req.send({
  AccountNumber: '',
  AdditionalInformation: '',
  PartyType: '',
  BusinessName: '',
  FirstName: '',
  MiddleName: '',
  LastName: '',
  BirthDate: '',
  Gender: '',
  PhoneNumber: '',
  MobilePhoneNumber: '',
  HomePhoneNumber: '',
  BusinessPhoneNumber: '',
  EmailAddress: '',
  PersonalEmailAddress: '',
  BusinessEmailAddress: '',
  Address: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  ShippingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  MailingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  BillingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  Attributes: {},
  PartyTypeString: '',
  GenderString: ''
});

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}}/domains/:DomainName/profiles',
  headers: {'content-type': 'application/json'},
  data: {
    AccountNumber: '',
    AdditionalInformation: '',
    PartyType: '',
    BusinessName: '',
    FirstName: '',
    MiddleName: '',
    LastName: '',
    BirthDate: '',
    Gender: '',
    PhoneNumber: '',
    MobilePhoneNumber: '',
    HomePhoneNumber: '',
    BusinessPhoneNumber: '',
    EmailAddress: '',
    PersonalEmailAddress: '',
    BusinessEmailAddress: '',
    Address: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    ShippingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    MailingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    BillingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    Attributes: {},
    PartyTypeString: '',
    GenderString: ''
  }
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccountNumber":"","AdditionalInformation":"","PartyType":"","BusinessName":"","FirstName":"","MiddleName":"","LastName":"","BirthDate":"","Gender":"","PhoneNumber":"","MobilePhoneNumber":"","HomePhoneNumber":"","BusinessPhoneNumber":"","EmailAddress":"","PersonalEmailAddress":"","BusinessEmailAddress":"","Address":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"ShippingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"MailingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"BillingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"Attributes":{},"PartyTypeString":"","GenderString":""}'
};

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 = @{ @"AccountNumber": @"",
                              @"AdditionalInformation": @"",
                              @"PartyType": @"",
                              @"BusinessName": @"",
                              @"FirstName": @"",
                              @"MiddleName": @"",
                              @"LastName": @"",
                              @"BirthDate": @"",
                              @"Gender": @"",
                              @"PhoneNumber": @"",
                              @"MobilePhoneNumber": @"",
                              @"HomePhoneNumber": @"",
                              @"BusinessPhoneNumber": @"",
                              @"EmailAddress": @"",
                              @"PersonalEmailAddress": @"",
                              @"BusinessEmailAddress": @"",
                              @"Address": @{ @"Address1": @"", @"Address2": @"", @"Address3": @"", @"Address4": @"", @"City": @"", @"County": @"", @"State": @"", @"Province": @"", @"Country": @"", @"PostalCode": @"" },
                              @"ShippingAddress": @{ @"Address1": @"", @"Address2": @"", @"Address3": @"", @"Address4": @"", @"City": @"", @"County": @"", @"State": @"", @"Province": @"", @"Country": @"", @"PostalCode": @"" },
                              @"MailingAddress": @{ @"Address1": @"", @"Address2": @"", @"Address3": @"", @"Address4": @"", @"City": @"", @"County": @"", @"State": @"", @"Province": @"", @"Country": @"", @"PostalCode": @"" },
                              @"BillingAddress": @{ @"Address1": @"", @"Address2": @"", @"Address3": @"", @"Address4": @"", @"City": @"", @"County": @"", @"State": @"", @"Province": @"", @"Country": @"", @"PostalCode": @"" },
                              @"Attributes": @{  },
                              @"PartyTypeString": @"",
                              @"GenderString": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles"]
                                                       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}}/domains/:DomainName/profiles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}" in

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

 "{{baseUrl}}/domains/:DomainName/profiles",
  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([
    'AccountNumber' => '',
    'AdditionalInformation' => '',
    'PartyType' => '',
    'BusinessName' => '',
    'FirstName' => '',
    'MiddleName' => '',
    'LastName' => '',
    'BirthDate' => '',
    'Gender' => '',
    'PhoneNumber' => '',
    'MobilePhoneNumber' => '',
    'HomePhoneNumber' => '',
    'BusinessPhoneNumber' => '',
    'EmailAddress' => '',
    'PersonalEmailAddress' => '',
    'BusinessEmailAddress' => '',
    'Address' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'City' => '',
        'County' => '',
        'State' => '',
        'Province' => '',
        'Country' => '',
        'PostalCode' => ''
    ],
    'ShippingAddress' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'City' => '',
        'County' => '',
        'State' => '',
        'Province' => '',
        'Country' => '',
        'PostalCode' => ''
    ],
    'MailingAddress' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'City' => '',
        'County' => '',
        'State' => '',
        'Province' => '',
        'Country' => '',
        'PostalCode' => ''
    ],
    'BillingAddress' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'City' => '',
        'County' => '',
        'State' => '',
        'Province' => '',
        'Country' => '',
        'PostalCode' => ''
    ],
    'Attributes' => [
        
    ],
    'PartyTypeString' => '',
    'GenderString' => ''
  ]),
  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}}/domains/:DomainName/profiles', [
  'body' => '{
  "AccountNumber": "",
  "AdditionalInformation": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccountNumber' => '',
  'AdditionalInformation' => '',
  'PartyType' => '',
  'BusinessName' => '',
  'FirstName' => '',
  'MiddleName' => '',
  'LastName' => '',
  'BirthDate' => '',
  'Gender' => '',
  'PhoneNumber' => '',
  'MobilePhoneNumber' => '',
  'HomePhoneNumber' => '',
  'BusinessPhoneNumber' => '',
  'EmailAddress' => '',
  'PersonalEmailAddress' => '',
  'BusinessEmailAddress' => '',
  'Address' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'ShippingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'MailingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'BillingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'Attributes' => [
    
  ],
  'PartyTypeString' => '',
  'GenderString' => ''
]));

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

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

append(json_encode([
  'AccountNumber' => '',
  'AdditionalInformation' => '',
  'PartyType' => '',
  'BusinessName' => '',
  'FirstName' => '',
  'MiddleName' => '',
  'LastName' => '',
  'BirthDate' => '',
  'Gender' => '',
  'PhoneNumber' => '',
  'MobilePhoneNumber' => '',
  'HomePhoneNumber' => '',
  'BusinessPhoneNumber' => '',
  'EmailAddress' => '',
  'PersonalEmailAddress' => '',
  'BusinessEmailAddress' => '',
  'Address' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'ShippingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'MailingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'BillingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'Attributes' => [
    
  ],
  'PartyTypeString' => '',
  'GenderString' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles');
$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}}/domains/:DomainName/profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountNumber": "",
  "AdditionalInformation": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountNumber": "",
  "AdditionalInformation": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}'

import http.client

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

payload = "{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}"

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

conn.request("POST", "/baseUrl/domains/:DomainName/profiles", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles"

payload = {
    "AccountNumber": "",
    "AdditionalInformation": "",
    "PartyType": "",
    "BusinessName": "",
    "FirstName": "",
    "MiddleName": "",
    "LastName": "",
    "BirthDate": "",
    "Gender": "",
    "PhoneNumber": "",
    "MobilePhoneNumber": "",
    "HomePhoneNumber": "",
    "BusinessPhoneNumber": "",
    "EmailAddress": "",
    "PersonalEmailAddress": "",
    "BusinessEmailAddress": "",
    "Address": {
        "Address1": "",
        "Address2": "",
        "Address3": "",
        "Address4": "",
        "City": "",
        "County": "",
        "State": "",
        "Province": "",
        "Country": "",
        "PostalCode": ""
    },
    "ShippingAddress": {
        "Address1": "",
        "Address2": "",
        "Address3": "",
        "Address4": "",
        "City": "",
        "County": "",
        "State": "",
        "Province": "",
        "Country": "",
        "PostalCode": ""
    },
    "MailingAddress": {
        "Address1": "",
        "Address2": "",
        "Address3": "",
        "Address4": "",
        "City": "",
        "County": "",
        "State": "",
        "Province": "",
        "Country": "",
        "PostalCode": ""
    },
    "BillingAddress": {
        "Address1": "",
        "Address2": "",
        "Address3": "",
        "Address4": "",
        "City": "",
        "County": "",
        "State": "",
        "Province": "",
        "Country": "",
        "PostalCode": ""
    },
    "Attributes": {},
    "PartyTypeString": "",
    "GenderString": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles"

payload <- "{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\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}}/domains/:DomainName/profiles")

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  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\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/domains/:DomainName/profiles') do |req|
  req.body = "{\n  \"AccountNumber\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "AccountNumber": "",
        "AdditionalInformation": "",
        "PartyType": "",
        "BusinessName": "",
        "FirstName": "",
        "MiddleName": "",
        "LastName": "",
        "BirthDate": "",
        "Gender": "",
        "PhoneNumber": "",
        "MobilePhoneNumber": "",
        "HomePhoneNumber": "",
        "BusinessPhoneNumber": "",
        "EmailAddress": "",
        "PersonalEmailAddress": "",
        "BusinessEmailAddress": "",
        "Address": json!({
            "Address1": "",
            "Address2": "",
            "Address3": "",
            "Address4": "",
            "City": "",
            "County": "",
            "State": "",
            "Province": "",
            "Country": "",
            "PostalCode": ""
        }),
        "ShippingAddress": json!({
            "Address1": "",
            "Address2": "",
            "Address3": "",
            "Address4": "",
            "City": "",
            "County": "",
            "State": "",
            "Province": "",
            "Country": "",
            "PostalCode": ""
        }),
        "MailingAddress": json!({
            "Address1": "",
            "Address2": "",
            "Address3": "",
            "Address4": "",
            "City": "",
            "County": "",
            "State": "",
            "Province": "",
            "Country": "",
            "PostalCode": ""
        }),
        "BillingAddress": json!({
            "Address1": "",
            "Address2": "",
            "Address3": "",
            "Address4": "",
            "City": "",
            "County": "",
            "State": "",
            "Province": "",
            "Country": "",
            "PostalCode": ""
        }),
        "Attributes": json!({}),
        "PartyTypeString": "",
        "GenderString": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "AccountNumber": "",
  "AdditionalInformation": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/profiles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccountNumber": "",\n  "AdditionalInformation": "",\n  "PartyType": "",\n  "BusinessName": "",\n  "FirstName": "",\n  "MiddleName": "",\n  "LastName": "",\n  "BirthDate": "",\n  "Gender": "",\n  "PhoneNumber": "",\n  "MobilePhoneNumber": "",\n  "HomePhoneNumber": "",\n  "BusinessPhoneNumber": "",\n  "EmailAddress": "",\n  "PersonalEmailAddress": "",\n  "BusinessEmailAddress": "",\n  "Address": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "ShippingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "MailingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "BillingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "Attributes": {},\n  "PartyTypeString": "",\n  "GenderString": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AccountNumber": "",
  "AdditionalInformation": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": [
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  ],
  "ShippingAddress": [
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  ],
  "MailingAddress": [
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  ],
  "BillingAddress": [
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  ],
  "Attributes": [],
  "PartyTypeString": "",
  "GenderString": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/domains/:DomainName")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName"

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

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

var client = new RestClient("{{baseUrl}}/domains/:DomainName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName"

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

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

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

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

}

DELETE /baseUrl/domains/:DomainName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/domains/:DomainName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/domains/:DomainName")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/domains/:DomainName');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/domains/:DomainName'};

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

const url = '{{baseUrl}}/domains/:DomainName';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/domains/:DomainName'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/domains/:DomainName');

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/domains/:DomainName'};

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

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

const url = '{{baseUrl}}/domains/:DomainName';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName" in

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

 "{{baseUrl}}/domains/:DomainName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/domains/:DomainName');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/domains/:DomainName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/domains/:DomainName")

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

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

response = conn.delete('/baseUrl/domains/:DomainName') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/domains/:DomainName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/domains/:DomainName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/integrations/delete");

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  \"Uri\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName/integrations/delete" {:content-type :json
                                                                                    :form-params {:Uri ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/integrations/delete"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Uri\": \"\"\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}}/domains/:DomainName/integrations/delete"),
    Content = new StringContent("{\n  \"Uri\": \"\"\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}}/domains/:DomainName/integrations/delete");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Uri\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/integrations/delete"

	payload := strings.NewReader("{\n  \"Uri\": \"\"\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/domains/:DomainName/integrations/delete HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "Uri": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/integrations/delete")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Uri\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/integrations/delete"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Uri\": \"\"\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  \"Uri\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/integrations/delete")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/integrations/delete")
  .header("content-type", "application/json")
  .body("{\n  \"Uri\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/integrations/delete');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/integrations/delete',
  headers: {'content-type': 'application/json'},
  data: {Uri: ''}
};

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

const url = '{{baseUrl}}/domains/:DomainName/integrations/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Uri":""}'
};

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}}/domains/:DomainName/integrations/delete',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Uri": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Uri\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/integrations/delete")
  .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/domains/:DomainName/integrations/delete',
  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({Uri: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/integrations/delete',
  headers: {'content-type': 'application/json'},
  body: {Uri: ''},
  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}}/domains/:DomainName/integrations/delete');

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

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

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}}/domains/:DomainName/integrations/delete',
  headers: {'content-type': 'application/json'},
  data: {Uri: ''}
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/integrations/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Uri":""}'
};

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 = @{ @"Uri": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/integrations/delete"]
                                                       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}}/domains/:DomainName/integrations/delete" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Uri\": \"\"\n}" in

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

 "{{baseUrl}}/domains/:DomainName/integrations/delete",
  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([
    'Uri' => ''
  ]),
  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}}/domains/:DomainName/integrations/delete', [
  'body' => '{
  "Uri": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/integrations/delete');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Uri' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/integrations/delete');
$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}}/domains/:DomainName/integrations/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Uri": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/integrations/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Uri": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/domains/:DomainName/integrations/delete", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/integrations/delete"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/integrations/delete"

payload <- "{\n  \"Uri\": \"\"\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}}/domains/:DomainName/integrations/delete")

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  \"Uri\": \"\"\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/domains/:DomainName/integrations/delete') do |req|
  req.body = "{\n  \"Uri\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

echo '{
  "Uri": ""
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/integrations/delete \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Uri": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/integrations/delete

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Uri": ""] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles/delete");

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  \"ProfileId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName/profiles/delete" {:content-type :json
                                                                                :form-params {:ProfileId ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles/delete"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProfileId\": \"\"\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}}/domains/:DomainName/profiles/delete"),
    Content = new StringContent("{\n  \"ProfileId\": \"\"\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}}/domains/:DomainName/profiles/delete");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProfileId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles/delete"

	payload := strings.NewReader("{\n  \"ProfileId\": \"\"\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/domains/:DomainName/profiles/delete HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "ProfileId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/profiles/delete")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProfileId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles/delete"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProfileId\": \"\"\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  \"ProfileId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/delete")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/profiles/delete")
  .header("content-type", "application/json")
  .body("{\n  \"ProfileId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/profiles/delete');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/delete',
  headers: {'content-type': 'application/json'},
  data: {ProfileId: ''}
};

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

const url = '{{baseUrl}}/domains/:DomainName/profiles/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":""}'
};

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}}/domains/:DomainName/profiles/delete',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProfileId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProfileId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/delete")
  .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/domains/:DomainName/profiles/delete',
  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({ProfileId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/delete',
  headers: {'content-type': 'application/json'},
  body: {ProfileId: ''},
  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}}/domains/:DomainName/profiles/delete');

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

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

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}}/domains/:DomainName/profiles/delete',
  headers: {'content-type': 'application/json'},
  data: {ProfileId: ''}
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/profiles/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":""}'
};

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 = @{ @"ProfileId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles/delete"]
                                                       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}}/domains/:DomainName/profiles/delete" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ProfileId\": \"\"\n}" in

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

 "{{baseUrl}}/domains/:DomainName/profiles/delete",
  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([
    'ProfileId' => ''
  ]),
  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}}/domains/:DomainName/profiles/delete', [
  'body' => '{
  "ProfileId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles/delete');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ProfileId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles/delete');
$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}}/domains/:DomainName/profiles/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/domains/:DomainName/profiles/delete", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles/delete"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles/delete"

payload <- "{\n  \"ProfileId\": \"\"\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}}/domains/:DomainName/profiles/delete")

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  \"ProfileId\": \"\"\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/domains/:DomainName/profiles/delete') do |req|
  req.body = "{\n  \"ProfileId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

echo '{
  "ProfileId": ""
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/profiles/delete \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProfileId": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles/delete

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ProfileId": ""] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles/keys/delete");

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  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName/profiles/keys/delete" {:content-type :json
                                                                                     :form-params {:ProfileId ""
                                                                                                   :KeyName ""
                                                                                                   :Values []}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles/keys/delete"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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}}/domains/:DomainName/profiles/keys/delete"),
    Content = new StringContent("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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}}/domains/:DomainName/profiles/keys/delete");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles/keys/delete"

	payload := strings.NewReader("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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/domains/:DomainName/profiles/keys/delete HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/profiles/keys/delete")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles/keys/delete"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/keys/delete")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/profiles/keys/delete")
  .header("content-type", "application/json")
  .body("{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}")
  .asString();

const data = JSON.stringify({
  ProfileId: '',
  KeyName: '',
  Values: []
});

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

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

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/profiles/keys/delete');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/keys/delete',
  headers: {'content-type': 'application/json'},
  data: {ProfileId: '', KeyName: '', Values: []}
};

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

const url = '{{baseUrl}}/domains/:DomainName/profiles/keys/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":"","KeyName":"","Values":[]}'
};

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}}/domains/:DomainName/profiles/keys/delete',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProfileId": "",\n  "KeyName": "",\n  "Values": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/keys/delete")
  .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/domains/:DomainName/profiles/keys/delete',
  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({ProfileId: '', KeyName: '', Values: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/keys/delete',
  headers: {'content-type': 'application/json'},
  body: {ProfileId: '', KeyName: '', Values: []},
  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}}/domains/:DomainName/profiles/keys/delete');

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

req.type('json');
req.send({
  ProfileId: '',
  KeyName: '',
  Values: []
});

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}}/domains/:DomainName/profiles/keys/delete',
  headers: {'content-type': 'application/json'},
  data: {ProfileId: '', KeyName: '', Values: []}
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/profiles/keys/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":"","KeyName":"","Values":[]}'
};

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 = @{ @"ProfileId": @"",
                              @"KeyName": @"",
                              @"Values": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles/keys/delete"]
                                                       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}}/domains/:DomainName/profiles/keys/delete" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}" in

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

 "{{baseUrl}}/domains/:DomainName/profiles/keys/delete",
  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([
    'ProfileId' => '',
    'KeyName' => '',
    'Values' => [
        
    ]
  ]),
  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}}/domains/:DomainName/profiles/keys/delete', [
  'body' => '{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles/keys/delete');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProfileId' => '',
  'KeyName' => '',
  'Values' => [
    
  ]
]));

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

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

append(json_encode([
  'ProfileId' => '',
  'KeyName' => '',
  'Values' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles/keys/delete');
$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}}/domains/:DomainName/profiles/keys/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles/keys/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}'

import http.client

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

payload = "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}"

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

conn.request("POST", "/baseUrl/domains/:DomainName/profiles/keys/delete", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles/keys/delete"

payload = {
    "ProfileId": "",
    "KeyName": "",
    "Values": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles/keys/delete"

payload <- "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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}}/domains/:DomainName/profiles/keys/delete")

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  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\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/domains/:DomainName/profiles/keys/delete') do |req|
  req.body = "{\n  \"ProfileId\": \"\",\n  \"KeyName\": \"\",\n  \"Values\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/profiles/keys/delete";

    let payload = json!({
        "ProfileId": "",
        "KeyName": "",
        "Values": ()
    });

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

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

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

    dbg!(results);
}

echo '{
  "ProfileId": "",
  "KeyName": "",
  "Values": []
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/profiles/keys/delete \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProfileId": "",\n  "KeyName": "",\n  "Values": []\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles/keys/delete

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ProfileId": "",
  "KeyName": "",
  "Values": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles/objects/delete");

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  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName/profiles/objects/delete" {:content-type :json
                                                                                        :form-params {:ProfileId ""
                                                                                                      :ProfileObjectUniqueKey ""
                                                                                                      :ObjectTypeName ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles/objects/delete"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\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}}/domains/:DomainName/profiles/objects/delete"),
    Content = new StringContent("{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\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}}/domains/:DomainName/profiles/objects/delete");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles/objects/delete"

	payload := strings.NewReader("{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\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/domains/:DomainName/profiles/objects/delete HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "ProfileId": "",
  "ProfileObjectUniqueKey": "",
  "ObjectTypeName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/profiles/objects/delete")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles/objects/delete"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\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  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/objects/delete")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/profiles/objects/delete")
  .header("content-type", "application/json")
  .body("{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ProfileId: '',
  ProfileObjectUniqueKey: '',
  ObjectTypeName: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/profiles/objects/delete');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/objects/delete',
  headers: {'content-type': 'application/json'},
  data: {ProfileId: '', ProfileObjectUniqueKey: '', ObjectTypeName: ''}
};

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

const url = '{{baseUrl}}/domains/:DomainName/profiles/objects/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":"","ProfileObjectUniqueKey":"","ObjectTypeName":""}'
};

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}}/domains/:DomainName/profiles/objects/delete',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProfileId": "",\n  "ProfileObjectUniqueKey": "",\n  "ObjectTypeName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/objects/delete")
  .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/domains/:DomainName/profiles/objects/delete',
  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({ProfileId: '', ProfileObjectUniqueKey: '', ObjectTypeName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/objects/delete',
  headers: {'content-type': 'application/json'},
  body: {ProfileId: '', ProfileObjectUniqueKey: '', ObjectTypeName: ''},
  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}}/domains/:DomainName/profiles/objects/delete');

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

req.type('json');
req.send({
  ProfileId: '',
  ProfileObjectUniqueKey: '',
  ObjectTypeName: ''
});

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}}/domains/:DomainName/profiles/objects/delete',
  headers: {'content-type': 'application/json'},
  data: {ProfileId: '', ProfileObjectUniqueKey: '', ObjectTypeName: ''}
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/profiles/objects/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":"","ProfileObjectUniqueKey":"","ObjectTypeName":""}'
};

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 = @{ @"ProfileId": @"",
                              @"ProfileObjectUniqueKey": @"",
                              @"ObjectTypeName": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles/objects/delete"]
                                                       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}}/domains/:DomainName/profiles/objects/delete" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\n}" in

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

 "{{baseUrl}}/domains/:DomainName/profiles/objects/delete",
  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([
    'ProfileId' => '',
    'ProfileObjectUniqueKey' => '',
    'ObjectTypeName' => ''
  ]),
  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}}/domains/:DomainName/profiles/objects/delete', [
  'body' => '{
  "ProfileId": "",
  "ProfileObjectUniqueKey": "",
  "ObjectTypeName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles/objects/delete');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProfileId' => '',
  'ProfileObjectUniqueKey' => '',
  'ObjectTypeName' => ''
]));

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

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

append(json_encode([
  'ProfileId' => '',
  'ProfileObjectUniqueKey' => '',
  'ObjectTypeName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles/objects/delete');
$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}}/domains/:DomainName/profiles/objects/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": "",
  "ProfileObjectUniqueKey": "",
  "ObjectTypeName": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles/objects/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": "",
  "ProfileObjectUniqueKey": "",
  "ObjectTypeName": ""
}'

import http.client

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

payload = "{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\n}"

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

conn.request("POST", "/baseUrl/domains/:DomainName/profiles/objects/delete", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles/objects/delete"

payload = {
    "ProfileId": "",
    "ProfileObjectUniqueKey": "",
    "ObjectTypeName": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles/objects/delete"

payload <- "{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\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}}/domains/:DomainName/profiles/objects/delete")

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  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\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/domains/:DomainName/profiles/objects/delete') do |req|
  req.body = "{\n  \"ProfileId\": \"\",\n  \"ProfileObjectUniqueKey\": \"\",\n  \"ObjectTypeName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/profiles/objects/delete";

    let payload = json!({
        "ProfileId": "",
        "ProfileObjectUniqueKey": "",
        "ObjectTypeName": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "ProfileId": "",
  "ProfileObjectUniqueKey": "",
  "ObjectTypeName": ""
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/profiles/objects/delete \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProfileId": "",\n  "ProfileObjectUniqueKey": "",\n  "ObjectTypeName": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles/objects/delete

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ProfileId": "",
  "ProfileObjectUniqueKey": "",
  "ObjectTypeName": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

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

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

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

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

}

DELETE /baseUrl/domains/:DomainName/object-types/:ObjectTypeName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName'
};

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

const url = '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/object-types/:ObjectTypeName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName'
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName" in

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

 "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/domains/:DomainName/object-types/:ObjectTypeName")

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

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

response = conn.delete('/baseUrl/domains/:DomainName/object-types/:ObjectTypeName') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"

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

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

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

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

}

DELETE /baseUrl/domains/:DomainName/workflows/:WorkflowId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId'
};

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

const url = '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/workflows/:WorkflowId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId'
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId" in

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

 "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/domains/:DomainName/workflows/:WorkflowId")

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

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

response = conn.delete('/baseUrl/domains/:DomainName/workflows/:WorkflowId') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/domains/:DomainName/workflows/:WorkflowId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/workflows/:WorkflowId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview");

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  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview" {:content-type :json
                                                                                                              :form-params {:Consolidation {:MatchingAttributesList ""}
                                                                                                                            :ConflictResolution {:ConflictResolvingModel ""
                                                                                                                                                 :SourceName ""}
                                                                                                                            :MinAllowedConfidenceScoreForMerging ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\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}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview"),
    Content = new StringContent("{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\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}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview"

	payload := strings.NewReader("{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\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/domains/:DomainName/identity-resolution-jobs/auto-merging-preview HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 192

{
  "Consolidation": {
    "MatchingAttributesList": ""
  },
  "ConflictResolution": {
    "ConflictResolvingModel": "",
    "SourceName": ""
  },
  "MinAllowedConfidenceScoreForMerging": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\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  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview")
  .header("content-type", "application/json")
  .body("{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Consolidation: {
    MatchingAttributesList: ''
  },
  ConflictResolution: {
    ConflictResolvingModel: '',
    SourceName: ''
  },
  MinAllowedConfidenceScoreForMerging: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview',
  headers: {'content-type': 'application/json'},
  data: {
    Consolidation: {MatchingAttributesList: ''},
    ConflictResolution: {ConflictResolvingModel: '', SourceName: ''},
    MinAllowedConfidenceScoreForMerging: ''
  }
};

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

const url = '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Consolidation":{"MatchingAttributesList":""},"ConflictResolution":{"ConflictResolvingModel":"","SourceName":""},"MinAllowedConfidenceScoreForMerging":""}'
};

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}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Consolidation": {\n    "MatchingAttributesList": ""\n  },\n  "ConflictResolution": {\n    "ConflictResolvingModel": "",\n    "SourceName": ""\n  },\n  "MinAllowedConfidenceScoreForMerging": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview")
  .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/domains/:DomainName/identity-resolution-jobs/auto-merging-preview',
  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({
  Consolidation: {MatchingAttributesList: ''},
  ConflictResolution: {ConflictResolvingModel: '', SourceName: ''},
  MinAllowedConfidenceScoreForMerging: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview',
  headers: {'content-type': 'application/json'},
  body: {
    Consolidation: {MatchingAttributesList: ''},
    ConflictResolution: {ConflictResolvingModel: '', SourceName: ''},
    MinAllowedConfidenceScoreForMerging: ''
  },
  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}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview');

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

req.type('json');
req.send({
  Consolidation: {
    MatchingAttributesList: ''
  },
  ConflictResolution: {
    ConflictResolvingModel: '',
    SourceName: ''
  },
  MinAllowedConfidenceScoreForMerging: ''
});

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}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview',
  headers: {'content-type': 'application/json'},
  data: {
    Consolidation: {MatchingAttributesList: ''},
    ConflictResolution: {ConflictResolvingModel: '', SourceName: ''},
    MinAllowedConfidenceScoreForMerging: ''
  }
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Consolidation":{"MatchingAttributesList":""},"ConflictResolution":{"ConflictResolvingModel":"","SourceName":""},"MinAllowedConfidenceScoreForMerging":""}'
};

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 = @{ @"Consolidation": @{ @"MatchingAttributesList": @"" },
                              @"ConflictResolution": @{ @"ConflictResolvingModel": @"", @"SourceName": @"" },
                              @"MinAllowedConfidenceScoreForMerging": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview"]
                                                       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}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\n}" in

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

 "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview",
  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([
    'Consolidation' => [
        'MatchingAttributesList' => ''
    ],
    'ConflictResolution' => [
        'ConflictResolvingModel' => '',
        'SourceName' => ''
    ],
    'MinAllowedConfidenceScoreForMerging' => ''
  ]),
  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}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview', [
  'body' => '{
  "Consolidation": {
    "MatchingAttributesList": ""
  },
  "ConflictResolution": {
    "ConflictResolvingModel": "",
    "SourceName": ""
  },
  "MinAllowedConfidenceScoreForMerging": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Consolidation' => [
    'MatchingAttributesList' => ''
  ],
  'ConflictResolution' => [
    'ConflictResolvingModel' => '',
    'SourceName' => ''
  ],
  'MinAllowedConfidenceScoreForMerging' => ''
]));

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

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

append(json_encode([
  'Consolidation' => [
    'MatchingAttributesList' => ''
  ],
  'ConflictResolution' => [
    'ConflictResolvingModel' => '',
    'SourceName' => ''
  ],
  'MinAllowedConfidenceScoreForMerging' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview');
$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}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Consolidation": {
    "MatchingAttributesList": ""
  },
  "ConflictResolution": {
    "ConflictResolvingModel": "",
    "SourceName": ""
  },
  "MinAllowedConfidenceScoreForMerging": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Consolidation": {
    "MatchingAttributesList": ""
  },
  "ConflictResolution": {
    "ConflictResolvingModel": "",
    "SourceName": ""
  },
  "MinAllowedConfidenceScoreForMerging": ""
}'

import http.client

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

payload = "{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\n}"

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

conn.request("POST", "/baseUrl/domains/:DomainName/identity-resolution-jobs/auto-merging-preview", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview"

payload = {
    "Consolidation": { "MatchingAttributesList": "" },
    "ConflictResolution": {
        "ConflictResolvingModel": "",
        "SourceName": ""
    },
    "MinAllowedConfidenceScoreForMerging": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview"

payload <- "{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\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}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview")

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  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\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/domains/:DomainName/identity-resolution-jobs/auto-merging-preview') do |req|
  req.body = "{\n  \"Consolidation\": {\n    \"MatchingAttributesList\": \"\"\n  },\n  \"ConflictResolution\": {\n    \"ConflictResolvingModel\": \"\",\n    \"SourceName\": \"\"\n  },\n  \"MinAllowedConfidenceScoreForMerging\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview";

    let payload = json!({
        "Consolidation": json!({"MatchingAttributesList": ""}),
        "ConflictResolution": json!({
            "ConflictResolvingModel": "",
            "SourceName": ""
        }),
        "MinAllowedConfidenceScoreForMerging": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "Consolidation": {
    "MatchingAttributesList": ""
  },
  "ConflictResolution": {
    "ConflictResolvingModel": "",
    "SourceName": ""
  },
  "MinAllowedConfidenceScoreForMerging": ""
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Consolidation": {\n    "MatchingAttributesList": ""\n  },\n  "ConflictResolution": {\n    "ConflictResolvingModel": "",\n    "SourceName": ""\n  },\n  "MinAllowedConfidenceScoreForMerging": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Consolidation": ["MatchingAttributesList": ""],
  "ConflictResolution": [
    "ConflictResolvingModel": "",
    "SourceName": ""
  ],
  "MinAllowedConfidenceScoreForMerging": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/auto-merging-preview")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/domains/:DomainName")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName"

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

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

var client = new RestClient("{{baseUrl}}/domains/:DomainName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName"

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

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

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

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

}

GET /baseUrl/domains/:DomainName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:DomainName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/domains/:DomainName")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/domains/:DomainName');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/domains/:DomainName'};

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

const url = '{{baseUrl}}/domains/:DomainName';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/domains/:DomainName'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domains/:DomainName');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/domains/:DomainName'};

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

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

const url = '{{baseUrl}}/domains/:DomainName';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName" in

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

 "{{baseUrl}}/domains/:DomainName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/domains/:DomainName');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/domains/:DomainName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/domains/:DomainName")

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/domains/:DomainName') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/domains/:DomainName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains/:DomainName

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId"

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

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

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

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

}

GET /baseUrl/domains/:DomainName/identity-resolution-jobs/:JobId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId'
};

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

const url = '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/identity-resolution-jobs/:JobId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId'
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId" in

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

 "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/domains/:DomainName/identity-resolution-jobs/:JobId")

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/domains/:DomainName/identity-resolution-jobs/:JobId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs/:JobId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/integrations");

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  \"Uri\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domains/:DomainName/integrations" {:content-type :json
                                                                             :form-params {:Uri ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/integrations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Uri\": \"\"\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}}/domains/:DomainName/integrations"),
    Content = new StringContent("{\n  \"Uri\": \"\"\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}}/domains/:DomainName/integrations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Uri\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/integrations"

	payload := strings.NewReader("{\n  \"Uri\": \"\"\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/domains/:DomainName/integrations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "Uri": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/integrations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Uri\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/integrations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Uri\": \"\"\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  \"Uri\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/integrations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/integrations")
  .header("content-type", "application/json")
  .body("{\n  \"Uri\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/integrations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/integrations',
  headers: {'content-type': 'application/json'},
  data: {Uri: ''}
};

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

const url = '{{baseUrl}}/domains/:DomainName/integrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Uri":""}'
};

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}}/domains/:DomainName/integrations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Uri": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Uri\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/integrations")
  .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/domains/:DomainName/integrations',
  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({Uri: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/integrations',
  headers: {'content-type': 'application/json'},
  body: {Uri: ''},
  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}}/domains/:DomainName/integrations');

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

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

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}}/domains/:DomainName/integrations',
  headers: {'content-type': 'application/json'},
  data: {Uri: ''}
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/integrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Uri":""}'
};

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 = @{ @"Uri": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/integrations"]
                                                       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}}/domains/:DomainName/integrations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Uri\": \"\"\n}" in

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

 "{{baseUrl}}/domains/:DomainName/integrations",
  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([
    'Uri' => ''
  ]),
  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}}/domains/:DomainName/integrations', [
  'body' => '{
  "Uri": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/integrations');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Uri' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/integrations');
$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}}/domains/:DomainName/integrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Uri": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/integrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Uri": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/domains/:DomainName/integrations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/integrations"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/integrations"

payload <- "{\n  \"Uri\": \"\"\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}}/domains/:DomainName/integrations")

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  \"Uri\": \"\"\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/domains/:DomainName/integrations') do |req|
  req.body = "{\n  \"Uri\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

echo '{
  "Uri": ""
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/integrations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Uri": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/integrations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Uri": ""] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/matches");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/domains/:DomainName/matches")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/matches"

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

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

var client = new RestClient("{{baseUrl}}/domains/:DomainName/matches");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/matches"

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

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

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

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

}

GET /baseUrl/domains/:DomainName/matches HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:DomainName/matches")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/matches"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/matches")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/domains/:DomainName/matches")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/domains/:DomainName/matches');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/domains/:DomainName/matches'};

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

const url = '{{baseUrl}}/domains/:DomainName/matches';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/matches',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/matches")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/matches',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/domains/:DomainName/matches'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domains/:DomainName/matches');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/domains/:DomainName/matches'};

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

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

const url = '{{baseUrl}}/domains/:DomainName/matches';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/matches"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/matches" in

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

 "{{baseUrl}}/domains/:DomainName/matches",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/domains/:DomainName/matches');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/matches');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/domains/:DomainName/matches');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/matches' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/matches' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/domains/:DomainName/matches")

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/matches"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/matches"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/matches")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/domains/:DomainName/matches') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/domains/:DomainName/matches

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/matches

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

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

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

var client = new RestClient("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

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

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

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

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

}

GET /baseUrl/domains/:DomainName/object-types/:ObjectTypeName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName'
};

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

const url = '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/object-types/:ObjectTypeName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName'
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName" in

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

 "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/domains/:DomainName/object-types/:ObjectTypeName")

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/domains/:DomainName/object-types/:ObjectTypeName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/templates/:TemplateId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/templates/:TemplateId")

require "http/client"

url = "{{baseUrl}}/templates/:TemplateId"

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

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

var client = new RestClient("{{baseUrl}}/templates/:TemplateId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/templates/:TemplateId"

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

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

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

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

}

GET /baseUrl/templates/:TemplateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/templates/:TemplateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/templates/:TemplateId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/templates/:TemplateId")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/templates/:TemplateId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/templates/:TemplateId'};

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

const url = '{{baseUrl}}/templates/:TemplateId';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/templates/:TemplateId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/templates/:TemplateId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/templates/:TemplateId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/templates/:TemplateId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/templates/:TemplateId');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/templates/:TemplateId'};

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

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

const url = '{{baseUrl}}/templates/:TemplateId';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/templates/:TemplateId" in

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

 "{{baseUrl}}/templates/:TemplateId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/templates/:TemplateId');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/templates/:TemplateId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/templates/:TemplateId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/templates/:TemplateId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/templates/:TemplateId")

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

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

import requests

url = "{{baseUrl}}/templates/:TemplateId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/templates/:TemplateId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/templates/:TemplateId")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/templates/:TemplateId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/templates/:TemplateId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/templates/:TemplateId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"

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

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

var client = new RestClient("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"

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

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

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

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

}

GET /baseUrl/domains/:DomainName/workflows/:WorkflowId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId'
};

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

const url = '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/workflows/:WorkflowId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId'
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId" in

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

 "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/domains/:DomainName/workflows/:WorkflowId")

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/domains/:DomainName/workflows/:WorkflowId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/domains/:DomainName/workflows/:WorkflowId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/workflows/:WorkflowId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps"

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

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

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

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

}

GET /baseUrl/domains/:DomainName/workflows/:WorkflowId/steps HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps'
};

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

const url = '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/workflows/:WorkflowId/steps',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps'
};

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

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

const url = '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps" in

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

 "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/domains/:DomainName/workflows/:WorkflowId/steps")

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

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

import requests

url = "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/domains/:DomainName/workflows/:WorkflowId/steps') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/workflows/:WorkflowId/steps")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"Uri\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/integrations" {:content-type :json
                                                         :form-params {:Uri ""}})

require "http/client"

url = "{{baseUrl}}/integrations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Uri\": \"\"\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}}/integrations"),
    Content = new StringContent("{\n  \"Uri\": \"\"\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}}/integrations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Uri\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"Uri\": \"\"\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/integrations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "Uri": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/integrations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Uri\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/integrations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Uri\": \"\"\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  \"Uri\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/integrations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/integrations")
  .header("content-type", "application/json")
  .body("{\n  \"Uri\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/integrations',
  headers: {'content-type': 'application/json'},
  data: {Uri: ''}
};

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

const url = '{{baseUrl}}/integrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Uri":""}'
};

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}}/integrations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Uri": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Uri\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/integrations")
  .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/integrations',
  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({Uri: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/integrations',
  headers: {'content-type': 'application/json'},
  body: {Uri: ''},
  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}}/integrations');

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

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

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}}/integrations',
  headers: {'content-type': 'application/json'},
  data: {Uri: ''}
};

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

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

const url = '{{baseUrl}}/integrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Uri":""}'
};

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 = @{ @"Uri": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/integrations"]
                                                       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}}/integrations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Uri\": \"\"\n}" in

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

 "{{baseUrl}}/integrations",
  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([
    'Uri' => ''
  ]),
  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}}/integrations', [
  'body' => '{
  "Uri": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'Uri' => ''
]));
$request->setRequestUrl('{{baseUrl}}/integrations');
$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}}/integrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Uri": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/integrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Uri": ""
}'

import http.client

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

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

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

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

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

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

import requests

url = "{{baseUrl}}/integrations"

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

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

print(response.json())

library(httr)

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

payload <- "{\n  \"Uri\": \"\"\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}}/integrations")

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  \"Uri\": \"\"\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/integrations') do |req|
  req.body = "{\n  \"Uri\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

echo '{
  "Uri": ""
}' |  \
  http POST {{baseUrl}}/integrations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Uri": ""\n}' \
  --output-document \
  - {{baseUrl}}/integrations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Uri": ""] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/domains")

require "http/client"

url = "{{baseUrl}}/domains"

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

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

var client = new RestClient("{{baseUrl}}/domains");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/domains HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/domains")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/domains');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/domains'};

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

const url = '{{baseUrl}}/domains';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains")
  .get()
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/domains'};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/domains'};

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

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

const url = '{{baseUrl}}/domains';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains" in

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

 "{{baseUrl}}/domains",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/domains');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/domains');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/domains")

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

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

import requests

url = "{{baseUrl}}/domains"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/domains') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/domains

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains

import Foundation

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/domains/:DomainName/identity-resolution-jobs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/identity-resolution-jobs',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/identity-resolution-jobs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/identity-resolution-jobs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/domains/:DomainName/identity-resolution-jobs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/identity-resolution-jobs' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/domains/:DomainName/identity-resolution-jobs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/identity-resolution-jobs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/domains/:DomainName/identity-resolution-jobs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/domains/:DomainName/identity-resolution-jobs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/identity-resolution-jobs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/identity-resolution-jobs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/integrations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/domains/:DomainName/integrations")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/integrations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/integrations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domains/:DomainName/integrations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/integrations"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/domains/:DomainName/integrations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:DomainName/integrations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/integrations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/integrations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/domains/:DomainName/integrations")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/domains/:DomainName/integrations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/integrations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/integrations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/integrations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/integrations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/integrations',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/integrations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domains/:DomainName/integrations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/integrations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/integrations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/integrations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/integrations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/integrations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/domains/:DomainName/integrations');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/integrations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/domains/:DomainName/integrations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/integrations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/integrations' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/domains/:DomainName/integrations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/integrations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/integrations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/integrations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/domains/:DomainName/integrations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/integrations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/domains/:DomainName/integrations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/integrations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/integrations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/templates");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/templates")

require "http/client"

url = "{{baseUrl}}/templates"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/templates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/templates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/templates"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/templates HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/templates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/templates"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/templates")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/templates")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/templates');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/templates'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/templates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/templates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/templates")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/templates',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/templates'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/templates');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/templates'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/templates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/templates"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/templates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/templates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/templates');

echo $response->getBody();

setUrl('{{baseUrl}}/templates');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/templates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/templates' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/templates' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/templates")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/templates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/templates"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/templates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/templates') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/templates";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/templates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/templates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/templates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/object-types");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/domains/:DomainName/object-types")

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/object-types"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/object-types"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domains/:DomainName/object-types");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/object-types"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/domains/:DomainName/object-types HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:DomainName/object-types")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/object-types"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/object-types")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/domains/:DomainName/object-types")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/domains/:DomainName/object-types');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/object-types'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/object-types';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domains/:DomainName/object-types',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/object-types")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/object-types',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/object-types'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domains/:DomainName/object-types');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domains/:DomainName/object-types'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/object-types';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/object-types"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/object-types" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/object-types",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/domains/:DomainName/object-types');

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/object-types');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/domains/:DomainName/object-types');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/object-types' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/object-types' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/domains/:DomainName/object-types")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/object-types"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/object-types"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/object-types")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/domains/:DomainName/object-types') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/object-types";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/domains/:DomainName/object-types

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/object-types

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/object-types")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles/objects");

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  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/domains/:DomainName/profiles/objects" {:content-type :json
                                                                                 :form-params {:ObjectTypeName ""
                                                                                               :ProfileId ""
                                                                                               :ObjectFilter {:KeyName ""
                                                                                                              :Values ""}}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles/objects"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/profiles/objects"),
    Content = new StringContent("{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domains/:DomainName/profiles/objects");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles/objects"

	payload := strings.NewReader("{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\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/domains/:DomainName/profiles/objects HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 106

{
  "ObjectTypeName": "",
  "ProfileId": "",
  "ObjectFilter": {
    "KeyName": "",
    "Values": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/profiles/objects")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles/objects"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/objects")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/profiles/objects")
  .header("content-type", "application/json")
  .body("{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  ObjectTypeName: '',
  ProfileId: '',
  ObjectFilter: {
    KeyName: '',
    Values: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/profiles/objects');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/objects',
  headers: {'content-type': 'application/json'},
  data: {ObjectTypeName: '', ProfileId: '', ObjectFilter: {KeyName: '', Values: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/profiles/objects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ObjectTypeName":"","ProfileId":"","ObjectFilter":{"KeyName":"","Values":""}}'
};

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}}/domains/:DomainName/profiles/objects',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ObjectTypeName": "",\n  "ProfileId": "",\n  "ObjectFilter": {\n    "KeyName": "",\n    "Values": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/objects")
  .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/domains/:DomainName/profiles/objects',
  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({ObjectTypeName: '', ProfileId: '', ObjectFilter: {KeyName: '', Values: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/objects',
  headers: {'content-type': 'application/json'},
  body: {ObjectTypeName: '', ProfileId: '', ObjectFilter: {KeyName: '', Values: ''}},
  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}}/domains/:DomainName/profiles/objects');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ObjectTypeName: '',
  ProfileId: '',
  ObjectFilter: {
    KeyName: '',
    Values: ''
  }
});

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}}/domains/:DomainName/profiles/objects',
  headers: {'content-type': 'application/json'},
  data: {ObjectTypeName: '', ProfileId: '', ObjectFilter: {KeyName: '', Values: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/profiles/objects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ObjectTypeName":"","ProfileId":"","ObjectFilter":{"KeyName":"","Values":""}}'
};

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 = @{ @"ObjectTypeName": @"",
                              @"ProfileId": @"",
                              @"ObjectFilter": @{ @"KeyName": @"", @"Values": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles/objects"]
                                                       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}}/domains/:DomainName/profiles/objects" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/profiles/objects",
  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([
    'ObjectTypeName' => '',
    'ProfileId' => '',
    'ObjectFilter' => [
        'KeyName' => '',
        'Values' => ''
    ]
  ]),
  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}}/domains/:DomainName/profiles/objects', [
  'body' => '{
  "ObjectTypeName": "",
  "ProfileId": "",
  "ObjectFilter": {
    "KeyName": "",
    "Values": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles/objects');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ObjectTypeName' => '',
  'ProfileId' => '',
  'ObjectFilter' => [
    'KeyName' => '',
    'Values' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ObjectTypeName' => '',
  'ProfileId' => '',
  'ObjectFilter' => [
    'KeyName' => '',
    'Values' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles/objects');
$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}}/domains/:DomainName/profiles/objects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ObjectTypeName": "",
  "ProfileId": "",
  "ObjectFilter": {
    "KeyName": "",
    "Values": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles/objects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ObjectTypeName": "",
  "ProfileId": "",
  "ObjectFilter": {
    "KeyName": "",
    "Values": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/domains/:DomainName/profiles/objects", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles/objects"

payload = {
    "ObjectTypeName": "",
    "ProfileId": "",
    "ObjectFilter": {
        "KeyName": "",
        "Values": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles/objects"

payload <- "{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/profiles/objects")

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  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/domains/:DomainName/profiles/objects') do |req|
  req.body = "{\n  \"ObjectTypeName\": \"\",\n  \"ProfileId\": \"\",\n  \"ObjectFilter\": {\n    \"KeyName\": \"\",\n    \"Values\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/profiles/objects";

    let payload = json!({
        "ObjectTypeName": "",
        "ProfileId": "",
        "ObjectFilter": json!({
            "KeyName": "",
            "Values": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "ObjectTypeName": "",
  "ProfileId": "",
  "ObjectFilter": {
    "KeyName": "",
    "Values": ""
  }
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/profiles/objects \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ObjectTypeName": "",\n  "ProfileId": "",\n  "ObjectFilter": {\n    "KeyName": "",\n    "Values": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles/objects

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ObjectTypeName": "",
  "ProfileId": "",
  "ObjectFilter": [
    "KeyName": "",
    "Values": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/profiles/objects")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tags/:resourceArn")

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tags/:resourceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tags/:resourceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tags/:resourceArn")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/tags/:resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tags/:resourceArn');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tags/:resourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tags/:resourceArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tags/:resourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/tags/:resourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/workflows");

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  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/domains/:DomainName/workflows" {:content-type :json
                                                                          :form-params {:WorkflowType ""
                                                                                        :Status ""
                                                                                        :QueryStartDate ""
                                                                                        :QueryEndDate ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/workflows"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\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}}/domains/:DomainName/workflows"),
    Content = new StringContent("{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\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}}/domains/:DomainName/workflows");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/workflows"

	payload := strings.NewReader("{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\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/domains/:DomainName/workflows HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 86

{
  "WorkflowType": "",
  "Status": "",
  "QueryStartDate": "",
  "QueryEndDate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/workflows")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/workflows"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\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  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/workflows")
  .header("content-type", "application/json")
  .body("{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WorkflowType: '',
  Status: '',
  QueryStartDate: '',
  QueryEndDate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/workflows');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/workflows',
  headers: {'content-type': 'application/json'},
  data: {WorkflowType: '', Status: '', QueryStartDate: '', QueryEndDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/workflows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"WorkflowType":"","Status":"","QueryStartDate":"","QueryEndDate":""}'
};

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}}/domains/:DomainName/workflows',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WorkflowType": "",\n  "Status": "",\n  "QueryStartDate": "",\n  "QueryEndDate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/workflows")
  .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/domains/:DomainName/workflows',
  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({WorkflowType: '', Status: '', QueryStartDate: '', QueryEndDate: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/workflows',
  headers: {'content-type': 'application/json'},
  body: {WorkflowType: '', Status: '', QueryStartDate: '', QueryEndDate: ''},
  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}}/domains/:DomainName/workflows');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WorkflowType: '',
  Status: '',
  QueryStartDate: '',
  QueryEndDate: ''
});

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}}/domains/:DomainName/workflows',
  headers: {'content-type': 'application/json'},
  data: {WorkflowType: '', Status: '', QueryStartDate: '', QueryEndDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/workflows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"WorkflowType":"","Status":"","QueryStartDate":"","QueryEndDate":""}'
};

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 = @{ @"WorkflowType": @"",
                              @"Status": @"",
                              @"QueryStartDate": @"",
                              @"QueryEndDate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/workflows"]
                                                       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}}/domains/:DomainName/workflows" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/workflows",
  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([
    'WorkflowType' => '',
    'Status' => '',
    'QueryStartDate' => '',
    'QueryEndDate' => ''
  ]),
  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}}/domains/:DomainName/workflows', [
  'body' => '{
  "WorkflowType": "",
  "Status": "",
  "QueryStartDate": "",
  "QueryEndDate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/workflows');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WorkflowType' => '',
  'Status' => '',
  'QueryStartDate' => '',
  'QueryEndDate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WorkflowType' => '',
  'Status' => '',
  'QueryStartDate' => '',
  'QueryEndDate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/workflows');
$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}}/domains/:DomainName/workflows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowType": "",
  "Status": "",
  "QueryStartDate": "",
  "QueryEndDate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/workflows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowType": "",
  "Status": "",
  "QueryStartDate": "",
  "QueryEndDate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/domains/:DomainName/workflows", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/workflows"

payload = {
    "WorkflowType": "",
    "Status": "",
    "QueryStartDate": "",
    "QueryEndDate": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/workflows"

payload <- "{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\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}}/domains/:DomainName/workflows")

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  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\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/domains/:DomainName/workflows') do |req|
  req.body = "{\n  \"WorkflowType\": \"\",\n  \"Status\": \"\",\n  \"QueryStartDate\": \"\",\n  \"QueryEndDate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/workflows";

    let payload = json!({
        "WorkflowType": "",
        "Status": "",
        "QueryStartDate": "",
        "QueryEndDate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "WorkflowType": "",
  "Status": "",
  "QueryStartDate": "",
  "QueryEndDate": ""
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/workflows \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "WorkflowType": "",\n  "Status": "",\n  "QueryStartDate": "",\n  "QueryEndDate": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/workflows

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "WorkflowType": "",
  "Status": "",
  "QueryStartDate": "",
  "QueryEndDate": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/workflows")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles/objects/merge");

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  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/domains/:DomainName/profiles/objects/merge" {:content-type :json
                                                                                       :form-params {:MainProfileId ""
                                                                                                     :ProfileIdsToBeMerged []
                                                                                                     :FieldSourceProfileIds {:AccountNumber ""
                                                                                                                             :AdditionalInformation ""
                                                                                                                             :PartyType ""
                                                                                                                             :BusinessName ""
                                                                                                                             :FirstName ""
                                                                                                                             :MiddleName ""
                                                                                                                             :LastName ""
                                                                                                                             :BirthDate ""
                                                                                                                             :Gender ""
                                                                                                                             :PhoneNumber ""
                                                                                                                             :MobilePhoneNumber ""
                                                                                                                             :HomePhoneNumber ""
                                                                                                                             :BusinessPhoneNumber ""
                                                                                                                             :EmailAddress ""
                                                                                                                             :PersonalEmailAddress ""
                                                                                                                             :BusinessEmailAddress ""
                                                                                                                             :Address ""
                                                                                                                             :ShippingAddress ""
                                                                                                                             :MailingAddress ""
                                                                                                                             :BillingAddress ""
                                                                                                                             :Attributes ""}}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles/objects/merge"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/profiles/objects/merge"),
    Content = new StringContent("{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domains/:DomainName/profiles/objects/merge");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles/objects/merge"

	payload := strings.NewReader("{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\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/domains/:DomainName/profiles/objects/merge HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 611

{
  "MainProfileId": "",
  "ProfileIdsToBeMerged": [],
  "FieldSourceProfileIds": {
    "AccountNumber": "",
    "AdditionalInformation": "",
    "PartyType": "",
    "BusinessName": "",
    "FirstName": "",
    "MiddleName": "",
    "LastName": "",
    "BirthDate": "",
    "Gender": "",
    "PhoneNumber": "",
    "MobilePhoneNumber": "",
    "HomePhoneNumber": "",
    "BusinessPhoneNumber": "",
    "EmailAddress": "",
    "PersonalEmailAddress": "",
    "BusinessEmailAddress": "",
    "Address": "",
    "ShippingAddress": "",
    "MailingAddress": "",
    "BillingAddress": "",
    "Attributes": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/profiles/objects/merge")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles/objects/merge"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/objects/merge")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/profiles/objects/merge")
  .header("content-type", "application/json")
  .body("{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  MainProfileId: '',
  ProfileIdsToBeMerged: [],
  FieldSourceProfileIds: {
    AccountNumber: '',
    AdditionalInformation: '',
    PartyType: '',
    BusinessName: '',
    FirstName: '',
    MiddleName: '',
    LastName: '',
    BirthDate: '',
    Gender: '',
    PhoneNumber: '',
    MobilePhoneNumber: '',
    HomePhoneNumber: '',
    BusinessPhoneNumber: '',
    EmailAddress: '',
    PersonalEmailAddress: '',
    BusinessEmailAddress: '',
    Address: '',
    ShippingAddress: '',
    MailingAddress: '',
    BillingAddress: '',
    Attributes: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/profiles/objects/merge');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/objects/merge',
  headers: {'content-type': 'application/json'},
  data: {
    MainProfileId: '',
    ProfileIdsToBeMerged: [],
    FieldSourceProfileIds: {
      AccountNumber: '',
      AdditionalInformation: '',
      PartyType: '',
      BusinessName: '',
      FirstName: '',
      MiddleName: '',
      LastName: '',
      BirthDate: '',
      Gender: '',
      PhoneNumber: '',
      MobilePhoneNumber: '',
      HomePhoneNumber: '',
      BusinessPhoneNumber: '',
      EmailAddress: '',
      PersonalEmailAddress: '',
      BusinessEmailAddress: '',
      Address: '',
      ShippingAddress: '',
      MailingAddress: '',
      BillingAddress: '',
      Attributes: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/profiles/objects/merge';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MainProfileId":"","ProfileIdsToBeMerged":[],"FieldSourceProfileIds":{"AccountNumber":"","AdditionalInformation":"","PartyType":"","BusinessName":"","FirstName":"","MiddleName":"","LastName":"","BirthDate":"","Gender":"","PhoneNumber":"","MobilePhoneNumber":"","HomePhoneNumber":"","BusinessPhoneNumber":"","EmailAddress":"","PersonalEmailAddress":"","BusinessEmailAddress":"","Address":"","ShippingAddress":"","MailingAddress":"","BillingAddress":"","Attributes":""}}'
};

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}}/domains/:DomainName/profiles/objects/merge',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MainProfileId": "",\n  "ProfileIdsToBeMerged": [],\n  "FieldSourceProfileIds": {\n    "AccountNumber": "",\n    "AdditionalInformation": "",\n    "PartyType": "",\n    "BusinessName": "",\n    "FirstName": "",\n    "MiddleName": "",\n    "LastName": "",\n    "BirthDate": "",\n    "Gender": "",\n    "PhoneNumber": "",\n    "MobilePhoneNumber": "",\n    "HomePhoneNumber": "",\n    "BusinessPhoneNumber": "",\n    "EmailAddress": "",\n    "PersonalEmailAddress": "",\n    "BusinessEmailAddress": "",\n    "Address": "",\n    "ShippingAddress": "",\n    "MailingAddress": "",\n    "BillingAddress": "",\n    "Attributes": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/objects/merge")
  .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/domains/:DomainName/profiles/objects/merge',
  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({
  MainProfileId: '',
  ProfileIdsToBeMerged: [],
  FieldSourceProfileIds: {
    AccountNumber: '',
    AdditionalInformation: '',
    PartyType: '',
    BusinessName: '',
    FirstName: '',
    MiddleName: '',
    LastName: '',
    BirthDate: '',
    Gender: '',
    PhoneNumber: '',
    MobilePhoneNumber: '',
    HomePhoneNumber: '',
    BusinessPhoneNumber: '',
    EmailAddress: '',
    PersonalEmailAddress: '',
    BusinessEmailAddress: '',
    Address: '',
    ShippingAddress: '',
    MailingAddress: '',
    BillingAddress: '',
    Attributes: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/objects/merge',
  headers: {'content-type': 'application/json'},
  body: {
    MainProfileId: '',
    ProfileIdsToBeMerged: [],
    FieldSourceProfileIds: {
      AccountNumber: '',
      AdditionalInformation: '',
      PartyType: '',
      BusinessName: '',
      FirstName: '',
      MiddleName: '',
      LastName: '',
      BirthDate: '',
      Gender: '',
      PhoneNumber: '',
      MobilePhoneNumber: '',
      HomePhoneNumber: '',
      BusinessPhoneNumber: '',
      EmailAddress: '',
      PersonalEmailAddress: '',
      BusinessEmailAddress: '',
      Address: '',
      ShippingAddress: '',
      MailingAddress: '',
      BillingAddress: '',
      Attributes: ''
    }
  },
  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}}/domains/:DomainName/profiles/objects/merge');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  MainProfileId: '',
  ProfileIdsToBeMerged: [],
  FieldSourceProfileIds: {
    AccountNumber: '',
    AdditionalInformation: '',
    PartyType: '',
    BusinessName: '',
    FirstName: '',
    MiddleName: '',
    LastName: '',
    BirthDate: '',
    Gender: '',
    PhoneNumber: '',
    MobilePhoneNumber: '',
    HomePhoneNumber: '',
    BusinessPhoneNumber: '',
    EmailAddress: '',
    PersonalEmailAddress: '',
    BusinessEmailAddress: '',
    Address: '',
    ShippingAddress: '',
    MailingAddress: '',
    BillingAddress: '',
    Attributes: ''
  }
});

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}}/domains/:DomainName/profiles/objects/merge',
  headers: {'content-type': 'application/json'},
  data: {
    MainProfileId: '',
    ProfileIdsToBeMerged: [],
    FieldSourceProfileIds: {
      AccountNumber: '',
      AdditionalInformation: '',
      PartyType: '',
      BusinessName: '',
      FirstName: '',
      MiddleName: '',
      LastName: '',
      BirthDate: '',
      Gender: '',
      PhoneNumber: '',
      MobilePhoneNumber: '',
      HomePhoneNumber: '',
      BusinessPhoneNumber: '',
      EmailAddress: '',
      PersonalEmailAddress: '',
      BusinessEmailAddress: '',
      Address: '',
      ShippingAddress: '',
      MailingAddress: '',
      BillingAddress: '',
      Attributes: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/profiles/objects/merge';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MainProfileId":"","ProfileIdsToBeMerged":[],"FieldSourceProfileIds":{"AccountNumber":"","AdditionalInformation":"","PartyType":"","BusinessName":"","FirstName":"","MiddleName":"","LastName":"","BirthDate":"","Gender":"","PhoneNumber":"","MobilePhoneNumber":"","HomePhoneNumber":"","BusinessPhoneNumber":"","EmailAddress":"","PersonalEmailAddress":"","BusinessEmailAddress":"","Address":"","ShippingAddress":"","MailingAddress":"","BillingAddress":"","Attributes":""}}'
};

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 = @{ @"MainProfileId": @"",
                              @"ProfileIdsToBeMerged": @[  ],
                              @"FieldSourceProfileIds": @{ @"AccountNumber": @"", @"AdditionalInformation": @"", @"PartyType": @"", @"BusinessName": @"", @"FirstName": @"", @"MiddleName": @"", @"LastName": @"", @"BirthDate": @"", @"Gender": @"", @"PhoneNumber": @"", @"MobilePhoneNumber": @"", @"HomePhoneNumber": @"", @"BusinessPhoneNumber": @"", @"EmailAddress": @"", @"PersonalEmailAddress": @"", @"BusinessEmailAddress": @"", @"Address": @"", @"ShippingAddress": @"", @"MailingAddress": @"", @"BillingAddress": @"", @"Attributes": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles/objects/merge"]
                                                       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}}/domains/:DomainName/profiles/objects/merge" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/profiles/objects/merge",
  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([
    'MainProfileId' => '',
    'ProfileIdsToBeMerged' => [
        
    ],
    'FieldSourceProfileIds' => [
        'AccountNumber' => '',
        'AdditionalInformation' => '',
        'PartyType' => '',
        'BusinessName' => '',
        'FirstName' => '',
        'MiddleName' => '',
        'LastName' => '',
        'BirthDate' => '',
        'Gender' => '',
        'PhoneNumber' => '',
        'MobilePhoneNumber' => '',
        'HomePhoneNumber' => '',
        'BusinessPhoneNumber' => '',
        'EmailAddress' => '',
        'PersonalEmailAddress' => '',
        'BusinessEmailAddress' => '',
        'Address' => '',
        'ShippingAddress' => '',
        'MailingAddress' => '',
        'BillingAddress' => '',
        'Attributes' => ''
    ]
  ]),
  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}}/domains/:DomainName/profiles/objects/merge', [
  'body' => '{
  "MainProfileId": "",
  "ProfileIdsToBeMerged": [],
  "FieldSourceProfileIds": {
    "AccountNumber": "",
    "AdditionalInformation": "",
    "PartyType": "",
    "BusinessName": "",
    "FirstName": "",
    "MiddleName": "",
    "LastName": "",
    "BirthDate": "",
    "Gender": "",
    "PhoneNumber": "",
    "MobilePhoneNumber": "",
    "HomePhoneNumber": "",
    "BusinessPhoneNumber": "",
    "EmailAddress": "",
    "PersonalEmailAddress": "",
    "BusinessEmailAddress": "",
    "Address": "",
    "ShippingAddress": "",
    "MailingAddress": "",
    "BillingAddress": "",
    "Attributes": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles/objects/merge');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MainProfileId' => '',
  'ProfileIdsToBeMerged' => [
    
  ],
  'FieldSourceProfileIds' => [
    'AccountNumber' => '',
    'AdditionalInformation' => '',
    'PartyType' => '',
    'BusinessName' => '',
    'FirstName' => '',
    'MiddleName' => '',
    'LastName' => '',
    'BirthDate' => '',
    'Gender' => '',
    'PhoneNumber' => '',
    'MobilePhoneNumber' => '',
    'HomePhoneNumber' => '',
    'BusinessPhoneNumber' => '',
    'EmailAddress' => '',
    'PersonalEmailAddress' => '',
    'BusinessEmailAddress' => '',
    'Address' => '',
    'ShippingAddress' => '',
    'MailingAddress' => '',
    'BillingAddress' => '',
    'Attributes' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'MainProfileId' => '',
  'ProfileIdsToBeMerged' => [
    
  ],
  'FieldSourceProfileIds' => [
    'AccountNumber' => '',
    'AdditionalInformation' => '',
    'PartyType' => '',
    'BusinessName' => '',
    'FirstName' => '',
    'MiddleName' => '',
    'LastName' => '',
    'BirthDate' => '',
    'Gender' => '',
    'PhoneNumber' => '',
    'MobilePhoneNumber' => '',
    'HomePhoneNumber' => '',
    'BusinessPhoneNumber' => '',
    'EmailAddress' => '',
    'PersonalEmailAddress' => '',
    'BusinessEmailAddress' => '',
    'Address' => '',
    'ShippingAddress' => '',
    'MailingAddress' => '',
    'BillingAddress' => '',
    'Attributes' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles/objects/merge');
$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}}/domains/:DomainName/profiles/objects/merge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MainProfileId": "",
  "ProfileIdsToBeMerged": [],
  "FieldSourceProfileIds": {
    "AccountNumber": "",
    "AdditionalInformation": "",
    "PartyType": "",
    "BusinessName": "",
    "FirstName": "",
    "MiddleName": "",
    "LastName": "",
    "BirthDate": "",
    "Gender": "",
    "PhoneNumber": "",
    "MobilePhoneNumber": "",
    "HomePhoneNumber": "",
    "BusinessPhoneNumber": "",
    "EmailAddress": "",
    "PersonalEmailAddress": "",
    "BusinessEmailAddress": "",
    "Address": "",
    "ShippingAddress": "",
    "MailingAddress": "",
    "BillingAddress": "",
    "Attributes": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles/objects/merge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MainProfileId": "",
  "ProfileIdsToBeMerged": [],
  "FieldSourceProfileIds": {
    "AccountNumber": "",
    "AdditionalInformation": "",
    "PartyType": "",
    "BusinessName": "",
    "FirstName": "",
    "MiddleName": "",
    "LastName": "",
    "BirthDate": "",
    "Gender": "",
    "PhoneNumber": "",
    "MobilePhoneNumber": "",
    "HomePhoneNumber": "",
    "BusinessPhoneNumber": "",
    "EmailAddress": "",
    "PersonalEmailAddress": "",
    "BusinessEmailAddress": "",
    "Address": "",
    "ShippingAddress": "",
    "MailingAddress": "",
    "BillingAddress": "",
    "Attributes": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/domains/:DomainName/profiles/objects/merge", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles/objects/merge"

payload = {
    "MainProfileId": "",
    "ProfileIdsToBeMerged": [],
    "FieldSourceProfileIds": {
        "AccountNumber": "",
        "AdditionalInformation": "",
        "PartyType": "",
        "BusinessName": "",
        "FirstName": "",
        "MiddleName": "",
        "LastName": "",
        "BirthDate": "",
        "Gender": "",
        "PhoneNumber": "",
        "MobilePhoneNumber": "",
        "HomePhoneNumber": "",
        "BusinessPhoneNumber": "",
        "EmailAddress": "",
        "PersonalEmailAddress": "",
        "BusinessEmailAddress": "",
        "Address": "",
        "ShippingAddress": "",
        "MailingAddress": "",
        "BillingAddress": "",
        "Attributes": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles/objects/merge"

payload <- "{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/profiles/objects/merge")

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  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/domains/:DomainName/profiles/objects/merge') do |req|
  req.body = "{\n  \"MainProfileId\": \"\",\n  \"ProfileIdsToBeMerged\": [],\n  \"FieldSourceProfileIds\": {\n    \"AccountNumber\": \"\",\n    \"AdditionalInformation\": \"\",\n    \"PartyType\": \"\",\n    \"BusinessName\": \"\",\n    \"FirstName\": \"\",\n    \"MiddleName\": \"\",\n    \"LastName\": \"\",\n    \"BirthDate\": \"\",\n    \"Gender\": \"\",\n    \"PhoneNumber\": \"\",\n    \"MobilePhoneNumber\": \"\",\n    \"HomePhoneNumber\": \"\",\n    \"BusinessPhoneNumber\": \"\",\n    \"EmailAddress\": \"\",\n    \"PersonalEmailAddress\": \"\",\n    \"BusinessEmailAddress\": \"\",\n    \"Address\": \"\",\n    \"ShippingAddress\": \"\",\n    \"MailingAddress\": \"\",\n    \"BillingAddress\": \"\",\n    \"Attributes\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/profiles/objects/merge";

    let payload = json!({
        "MainProfileId": "",
        "ProfileIdsToBeMerged": (),
        "FieldSourceProfileIds": json!({
            "AccountNumber": "",
            "AdditionalInformation": "",
            "PartyType": "",
            "BusinessName": "",
            "FirstName": "",
            "MiddleName": "",
            "LastName": "",
            "BirthDate": "",
            "Gender": "",
            "PhoneNumber": "",
            "MobilePhoneNumber": "",
            "HomePhoneNumber": "",
            "BusinessPhoneNumber": "",
            "EmailAddress": "",
            "PersonalEmailAddress": "",
            "BusinessEmailAddress": "",
            "Address": "",
            "ShippingAddress": "",
            "MailingAddress": "",
            "BillingAddress": "",
            "Attributes": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "MainProfileId": "",
  "ProfileIdsToBeMerged": [],
  "FieldSourceProfileIds": {
    "AccountNumber": "",
    "AdditionalInformation": "",
    "PartyType": "",
    "BusinessName": "",
    "FirstName": "",
    "MiddleName": "",
    "LastName": "",
    "BirthDate": "",
    "Gender": "",
    "PhoneNumber": "",
    "MobilePhoneNumber": "",
    "HomePhoneNumber": "",
    "BusinessPhoneNumber": "",
    "EmailAddress": "",
    "PersonalEmailAddress": "",
    "BusinessEmailAddress": "",
    "Address": "",
    "ShippingAddress": "",
    "MailingAddress": "",
    "BillingAddress": "",
    "Attributes": ""
  }
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/profiles/objects/merge \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "MainProfileId": "",\n  "ProfileIdsToBeMerged": [],\n  "FieldSourceProfileIds": {\n    "AccountNumber": "",\n    "AdditionalInformation": "",\n    "PartyType": "",\n    "BusinessName": "",\n    "FirstName": "",\n    "MiddleName": "",\n    "LastName": "",\n    "BirthDate": "",\n    "Gender": "",\n    "PhoneNumber": "",\n    "MobilePhoneNumber": "",\n    "HomePhoneNumber": "",\n    "BusinessPhoneNumber": "",\n    "EmailAddress": "",\n    "PersonalEmailAddress": "",\n    "BusinessEmailAddress": "",\n    "Address": "",\n    "ShippingAddress": "",\n    "MailingAddress": "",\n    "BillingAddress": "",\n    "Attributes": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles/objects/merge

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "MainProfileId": "",
  "ProfileIdsToBeMerged": [],
  "FieldSourceProfileIds": [
    "AccountNumber": "",
    "AdditionalInformation": "",
    "PartyType": "",
    "BusinessName": "",
    "FirstName": "",
    "MiddleName": "",
    "LastName": "",
    "BirthDate": "",
    "Gender": "",
    "PhoneNumber": "",
    "MobilePhoneNumber": "",
    "HomePhoneNumber": "",
    "BusinessPhoneNumber": "",
    "EmailAddress": "",
    "PersonalEmailAddress": "",
    "BusinessEmailAddress": "",
    "Address": "",
    "ShippingAddress": "",
    "MailingAddress": "",
    "BillingAddress": "",
    "Attributes": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/profiles/objects/merge")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/integrations");

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  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/domains/:DomainName/integrations" {:content-type :json
                                                                            :form-params {:Uri ""
                                                                                          :ObjectTypeName ""
                                                                                          :Tags {}
                                                                                          :FlowDefinition {:Description ""
                                                                                                           :FlowName ""
                                                                                                           :KmsArn ""
                                                                                                           :SourceFlowConfig ""
                                                                                                           :Tasks ""
                                                                                                           :TriggerConfig ""}
                                                                                          :ObjectTypeNames {}}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/integrations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/integrations"),
    Content = new StringContent("{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\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}}/domains/:DomainName/integrations");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/integrations"

	payload := strings.NewReader("{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/domains/:DomainName/integrations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 235

{
  "Uri": "",
  "ObjectTypeName": "",
  "Tags": {},
  "FlowDefinition": {
    "Description": "",
    "FlowName": "",
    "KmsArn": "",
    "SourceFlowConfig": "",
    "Tasks": "",
    "TriggerConfig": ""
  },
  "ObjectTypeNames": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/domains/:DomainName/integrations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/integrations"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\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  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/integrations")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/domains/:DomainName/integrations")
  .header("content-type", "application/json")
  .body("{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}")
  .asString();

const data = JSON.stringify({
  Uri: '',
  ObjectTypeName: '',
  Tags: {},
  FlowDefinition: {
    Description: '',
    FlowName: '',
    KmsArn: '',
    SourceFlowConfig: '',
    Tasks: '',
    TriggerConfig: ''
  },
  ObjectTypeNames: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/domains/:DomainName/integrations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/integrations',
  headers: {'content-type': 'application/json'},
  data: {
    Uri: '',
    ObjectTypeName: '',
    Tags: {},
    FlowDefinition: {
      Description: '',
      FlowName: '',
      KmsArn: '',
      SourceFlowConfig: '',
      Tasks: '',
      TriggerConfig: ''
    },
    ObjectTypeNames: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/integrations';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Uri":"","ObjectTypeName":"","Tags":{},"FlowDefinition":{"Description":"","FlowName":"","KmsArn":"","SourceFlowConfig":"","Tasks":"","TriggerConfig":""},"ObjectTypeNames":{}}'
};

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}}/domains/:DomainName/integrations',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Uri": "",\n  "ObjectTypeName": "",\n  "Tags": {},\n  "FlowDefinition": {\n    "Description": "",\n    "FlowName": "",\n    "KmsArn": "",\n    "SourceFlowConfig": "",\n    "Tasks": "",\n    "TriggerConfig": ""\n  },\n  "ObjectTypeNames": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/integrations")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/integrations',
  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({
  Uri: '',
  ObjectTypeName: '',
  Tags: {},
  FlowDefinition: {
    Description: '',
    FlowName: '',
    KmsArn: '',
    SourceFlowConfig: '',
    Tasks: '',
    TriggerConfig: ''
  },
  ObjectTypeNames: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/integrations',
  headers: {'content-type': 'application/json'},
  body: {
    Uri: '',
    ObjectTypeName: '',
    Tags: {},
    FlowDefinition: {
      Description: '',
      FlowName: '',
      KmsArn: '',
      SourceFlowConfig: '',
      Tasks: '',
      TriggerConfig: ''
    },
    ObjectTypeNames: {}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/domains/:DomainName/integrations');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Uri: '',
  ObjectTypeName: '',
  Tags: {},
  FlowDefinition: {
    Description: '',
    FlowName: '',
    KmsArn: '',
    SourceFlowConfig: '',
    Tasks: '',
    TriggerConfig: ''
  },
  ObjectTypeNames: {}
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/integrations',
  headers: {'content-type': 'application/json'},
  data: {
    Uri: '',
    ObjectTypeName: '',
    Tags: {},
    FlowDefinition: {
      Description: '',
      FlowName: '',
      KmsArn: '',
      SourceFlowConfig: '',
      Tasks: '',
      TriggerConfig: ''
    },
    ObjectTypeNames: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/integrations';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Uri":"","ObjectTypeName":"","Tags":{},"FlowDefinition":{"Description":"","FlowName":"","KmsArn":"","SourceFlowConfig":"","Tasks":"","TriggerConfig":""},"ObjectTypeNames":{}}'
};

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 = @{ @"Uri": @"",
                              @"ObjectTypeName": @"",
                              @"Tags": @{  },
                              @"FlowDefinition": @{ @"Description": @"", @"FlowName": @"", @"KmsArn": @"", @"SourceFlowConfig": @"", @"Tasks": @"", @"TriggerConfig": @"" },
                              @"ObjectTypeNames": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/integrations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/integrations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/integrations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Uri' => '',
    'ObjectTypeName' => '',
    'Tags' => [
        
    ],
    'FlowDefinition' => [
        'Description' => '',
        'FlowName' => '',
        'KmsArn' => '',
        'SourceFlowConfig' => '',
        'Tasks' => '',
        'TriggerConfig' => ''
    ],
    'ObjectTypeNames' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/domains/:DomainName/integrations', [
  'body' => '{
  "Uri": "",
  "ObjectTypeName": "",
  "Tags": {},
  "FlowDefinition": {
    "Description": "",
    "FlowName": "",
    "KmsArn": "",
    "SourceFlowConfig": "",
    "Tasks": "",
    "TriggerConfig": ""
  },
  "ObjectTypeNames": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/integrations');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Uri' => '',
  'ObjectTypeName' => '',
  'Tags' => [
    
  ],
  'FlowDefinition' => [
    'Description' => '',
    'FlowName' => '',
    'KmsArn' => '',
    'SourceFlowConfig' => '',
    'Tasks' => '',
    'TriggerConfig' => ''
  ],
  'ObjectTypeNames' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Uri' => '',
  'ObjectTypeName' => '',
  'Tags' => [
    
  ],
  'FlowDefinition' => [
    'Description' => '',
    'FlowName' => '',
    'KmsArn' => '',
    'SourceFlowConfig' => '',
    'Tasks' => '',
    'TriggerConfig' => ''
  ],
  'ObjectTypeNames' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/integrations');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/integrations' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Uri": "",
  "ObjectTypeName": "",
  "Tags": {},
  "FlowDefinition": {
    "Description": "",
    "FlowName": "",
    "KmsArn": "",
    "SourceFlowConfig": "",
    "Tasks": "",
    "TriggerConfig": ""
  },
  "ObjectTypeNames": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/integrations' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Uri": "",
  "ObjectTypeName": "",
  "Tags": {},
  "FlowDefinition": {
    "Description": "",
    "FlowName": "",
    "KmsArn": "",
    "SourceFlowConfig": "",
    "Tasks": "",
    "TriggerConfig": ""
  },
  "ObjectTypeNames": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/domains/:DomainName/integrations", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/integrations"

payload = {
    "Uri": "",
    "ObjectTypeName": "",
    "Tags": {},
    "FlowDefinition": {
        "Description": "",
        "FlowName": "",
        "KmsArn": "",
        "SourceFlowConfig": "",
        "Tasks": "",
        "TriggerConfig": ""
    },
    "ObjectTypeNames": {}
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/integrations"

payload <- "{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/integrations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/domains/:DomainName/integrations') do |req|
  req.body = "{\n  \"Uri\": \"\",\n  \"ObjectTypeName\": \"\",\n  \"Tags\": {},\n  \"FlowDefinition\": {\n    \"Description\": \"\",\n    \"FlowName\": \"\",\n    \"KmsArn\": \"\",\n    \"SourceFlowConfig\": \"\",\n    \"Tasks\": \"\",\n    \"TriggerConfig\": \"\"\n  },\n  \"ObjectTypeNames\": {}\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/integrations";

    let payload = json!({
        "Uri": "",
        "ObjectTypeName": "",
        "Tags": json!({}),
        "FlowDefinition": json!({
            "Description": "",
            "FlowName": "",
            "KmsArn": "",
            "SourceFlowConfig": "",
            "Tasks": "",
            "TriggerConfig": ""
        }),
        "ObjectTypeNames": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Uri": "",
  "ObjectTypeName": "",
  "Tags": {},
  "FlowDefinition": {
    "Description": "",
    "FlowName": "",
    "KmsArn": "",
    "SourceFlowConfig": "",
    "Tasks": "",
    "TriggerConfig": ""
  },
  "ObjectTypeNames": {}
}' |  \
  http PUT {{baseUrl}}/domains/:DomainName/integrations \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Uri": "",\n  "ObjectTypeName": "",\n  "Tags": {},\n  "FlowDefinition": {\n    "Description": "",\n    "FlowName": "",\n    "KmsArn": "",\n    "SourceFlowConfig": "",\n    "Tasks": "",\n    "TriggerConfig": ""\n  },\n  "ObjectTypeNames": {}\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/integrations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Uri": "",
  "ObjectTypeName": "",
  "Tags": [],
  "FlowDefinition": [
    "Description": "",
    "FlowName": "",
    "KmsArn": "",
    "SourceFlowConfig": "",
    "Tasks": "",
    "TriggerConfig": ""
  ],
  "ObjectTypeNames": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/integrations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles/objects");

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  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/domains/:DomainName/profiles/objects" {:content-type :json
                                                                                :form-params {:ObjectTypeName ""
                                                                                              :Object ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles/objects"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/profiles/objects"),
    Content = new StringContent("{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\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}}/domains/:DomainName/profiles/objects");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles/objects"

	payload := strings.NewReader("{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/domains/:DomainName/profiles/objects HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "ObjectTypeName": "",
  "Object": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/domains/:DomainName/profiles/objects")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles/objects"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\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  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/objects")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/domains/:DomainName/profiles/objects")
  .header("content-type", "application/json")
  .body("{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ObjectTypeName: '',
  Object: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/domains/:DomainName/profiles/objects');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/profiles/objects',
  headers: {'content-type': 'application/json'},
  data: {ObjectTypeName: '', Object: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/profiles/objects';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ObjectTypeName":"","Object":""}'
};

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}}/domains/:DomainName/profiles/objects',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ObjectTypeName": "",\n  "Object": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/objects")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/profiles/objects',
  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({ObjectTypeName: '', Object: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/profiles/objects',
  headers: {'content-type': 'application/json'},
  body: {ObjectTypeName: '', Object: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/domains/:DomainName/profiles/objects');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ObjectTypeName: '',
  Object: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/profiles/objects',
  headers: {'content-type': 'application/json'},
  data: {ObjectTypeName: '', Object: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/profiles/objects';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ObjectTypeName":"","Object":""}'
};

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 = @{ @"ObjectTypeName": @"",
                              @"Object": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles/objects"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/profiles/objects" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/profiles/objects",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'ObjectTypeName' => '',
    'Object' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/domains/:DomainName/profiles/objects', [
  'body' => '{
  "ObjectTypeName": "",
  "Object": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles/objects');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ObjectTypeName' => '',
  'Object' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ObjectTypeName' => '',
  'Object' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles/objects');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/profiles/objects' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ObjectTypeName": "",
  "Object": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles/objects' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ObjectTypeName": "",
  "Object": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/domains/:DomainName/profiles/objects", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles/objects"

payload = {
    "ObjectTypeName": "",
    "Object": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles/objects"

payload <- "{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/profiles/objects")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/domains/:DomainName/profiles/objects') do |req|
  req.body = "{\n  \"ObjectTypeName\": \"\",\n  \"Object\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/profiles/objects";

    let payload = json!({
        "ObjectTypeName": "",
        "Object": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "ObjectTypeName": "",
  "Object": ""
}' |  \
  http PUT {{baseUrl}}/domains/:DomainName/profiles/objects \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ObjectTypeName": "",\n  "Object": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles/objects

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ObjectTypeName": "",
  "Object": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/profiles/objects")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName");

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  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName" {:content-type :json
                                                                                            :form-params {:Description ""
                                                                                                          :TemplateId ""
                                                                                                          :ExpirationDays 0
                                                                                                          :EncryptionKey ""
                                                                                                          :AllowProfileCreation false
                                                                                                          :SourceLastUpdatedTimestampFormat ""
                                                                                                          :Fields {}
                                                                                                          :Keys {}
                                                                                                          :Tags {}}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"),
    Content = new StringContent("{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\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}}/domains/:DomainName/object-types/:ObjectTypeName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

	payload := strings.NewReader("{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/domains/:DomainName/object-types/:ObjectTypeName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 208

{
  "Description": "",
  "TemplateId": "",
  "ExpirationDays": 0,
  "EncryptionKey": "",
  "AllowProfileCreation": false,
  "SourceLastUpdatedTimestampFormat": "",
  "Fields": {},
  "Keys": {},
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .header("content-type", "application/json")
  .body("{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Description: '',
  TemplateId: '',
  ExpirationDays: 0,
  EncryptionKey: '',
  AllowProfileCreation: false,
  SourceLastUpdatedTimestampFormat: '',
  Fields: {},
  Keys: {},
  Tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    TemplateId: '',
    ExpirationDays: 0,
    EncryptionKey: '',
    AllowProfileCreation: false,
    SourceLastUpdatedTimestampFormat: '',
    Fields: {},
    Keys: {},
    Tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","TemplateId":"","ExpirationDays":0,"EncryptionKey":"","AllowProfileCreation":false,"SourceLastUpdatedTimestampFormat":"","Fields":{},"Keys":{},"Tags":{}}'
};

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}}/domains/:DomainName/object-types/:ObjectTypeName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Description": "",\n  "TemplateId": "",\n  "ExpirationDays": 0,\n  "EncryptionKey": "",\n  "AllowProfileCreation": false,\n  "SourceLastUpdatedTimestampFormat": "",\n  "Fields": {},\n  "Keys": {},\n  "Tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/object-types/:ObjectTypeName',
  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({
  Description: '',
  TemplateId: '',
  ExpirationDays: 0,
  EncryptionKey: '',
  AllowProfileCreation: false,
  SourceLastUpdatedTimestampFormat: '',
  Fields: {},
  Keys: {},
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName',
  headers: {'content-type': 'application/json'},
  body: {
    Description: '',
    TemplateId: '',
    ExpirationDays: 0,
    EncryptionKey: '',
    AllowProfileCreation: false,
    SourceLastUpdatedTimestampFormat: '',
    Fields: {},
    Keys: {},
    Tags: {}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Description: '',
  TemplateId: '',
  ExpirationDays: 0,
  EncryptionKey: '',
  AllowProfileCreation: false,
  SourceLastUpdatedTimestampFormat: '',
  Fields: {},
  Keys: {},
  Tags: {}
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    TemplateId: '',
    ExpirationDays: 0,
    EncryptionKey: '',
    AllowProfileCreation: false,
    SourceLastUpdatedTimestampFormat: '',
    Fields: {},
    Keys: {},
    Tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","TemplateId":"","ExpirationDays":0,"EncryptionKey":"","AllowProfileCreation":false,"SourceLastUpdatedTimestampFormat":"","Fields":{},"Keys":{},"Tags":{}}'
};

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 = @{ @"Description": @"",
                              @"TemplateId": @"",
                              @"ExpirationDays": @0,
                              @"EncryptionKey": @"",
                              @"AllowProfileCreation": @NO,
                              @"SourceLastUpdatedTimestampFormat": @"",
                              @"Fields": @{  },
                              @"Keys": @{  },
                              @"Tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Description' => '',
    'TemplateId' => '',
    'ExpirationDays' => 0,
    'EncryptionKey' => '',
    'AllowProfileCreation' => null,
    'SourceLastUpdatedTimestampFormat' => '',
    'Fields' => [
        
    ],
    'Keys' => [
        
    ],
    'Tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName', [
  'body' => '{
  "Description": "",
  "TemplateId": "",
  "ExpirationDays": 0,
  "EncryptionKey": "",
  "AllowProfileCreation": false,
  "SourceLastUpdatedTimestampFormat": "",
  "Fields": {},
  "Keys": {},
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Description' => '',
  'TemplateId' => '',
  'ExpirationDays' => 0,
  'EncryptionKey' => '',
  'AllowProfileCreation' => null,
  'SourceLastUpdatedTimestampFormat' => '',
  'Fields' => [
    
  ],
  'Keys' => [
    
  ],
  'Tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Description' => '',
  'TemplateId' => '',
  'ExpirationDays' => 0,
  'EncryptionKey' => '',
  'AllowProfileCreation' => null,
  'SourceLastUpdatedTimestampFormat' => '',
  'Fields' => [
    
  ],
  'Keys' => [
    
  ],
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "TemplateId": "",
  "ExpirationDays": 0,
  "EncryptionKey": "",
  "AllowProfileCreation": false,
  "SourceLastUpdatedTimestampFormat": "",
  "Fields": {},
  "Keys": {},
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "TemplateId": "",
  "ExpirationDays": 0,
  "EncryptionKey": "",
  "AllowProfileCreation": false,
  "SourceLastUpdatedTimestampFormat": "",
  "Fields": {},
  "Keys": {},
  "Tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/domains/:DomainName/object-types/:ObjectTypeName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

payload = {
    "Description": "",
    "TemplateId": "",
    "ExpirationDays": 0,
    "EncryptionKey": "",
    "AllowProfileCreation": False,
    "SourceLastUpdatedTimestampFormat": "",
    "Fields": {},
    "Keys": {},
    "Tags": {}
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName"

payload <- "{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/domains/:DomainName/object-types/:ObjectTypeName') do |req|
  req.body = "{\n  \"Description\": \"\",\n  \"TemplateId\": \"\",\n  \"ExpirationDays\": 0,\n  \"EncryptionKey\": \"\",\n  \"AllowProfileCreation\": false,\n  \"SourceLastUpdatedTimestampFormat\": \"\",\n  \"Fields\": {},\n  \"Keys\": {},\n  \"Tags\": {}\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName";

    let payload = json!({
        "Description": "",
        "TemplateId": "",
        "ExpirationDays": 0,
        "EncryptionKey": "",
        "AllowProfileCreation": false,
        "SourceLastUpdatedTimestampFormat": "",
        "Fields": json!({}),
        "Keys": json!({}),
        "Tags": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Description": "",
  "TemplateId": "",
  "ExpirationDays": 0,
  "EncryptionKey": "",
  "AllowProfileCreation": false,
  "SourceLastUpdatedTimestampFormat": "",
  "Fields": {},
  "Keys": {},
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": "",\n  "TemplateId": "",\n  "ExpirationDays": 0,\n  "EncryptionKey": "",\n  "AllowProfileCreation": false,\n  "SourceLastUpdatedTimestampFormat": "",\n  "Fields": {},\n  "Keys": {},\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Description": "",
  "TemplateId": "",
  "ExpirationDays": 0,
  "EncryptionKey": "",
  "AllowProfileCreation": false,
  "SourceLastUpdatedTimestampFormat": "",
  "Fields": [],
  "Keys": [],
  "Tags": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/object-types/:ObjectTypeName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles/search");

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  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/domains/:DomainName/profiles/search" {:content-type :json
                                                                                :form-params {:KeyName ""
                                                                                              :Values []
                                                                                              :AdditionalSearchKeys [{:KeyName ""
                                                                                                                      :Values ""}]
                                                                                              :LogicalOperator ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\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}}/domains/:DomainName/profiles/search"),
    Content = new StringContent("{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\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}}/domains/:DomainName/profiles/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles/search"

	payload := strings.NewReader("{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\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/domains/:DomainName/profiles/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 145

{
  "KeyName": "",
  "Values": [],
  "AdditionalSearchKeys": [
    {
      "KeyName": "",
      "Values": ""
    }
  ],
  "LogicalOperator": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domains/:DomainName/profiles/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\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  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/domains/:DomainName/profiles/search")
  .header("content-type", "application/json")
  .body("{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  KeyName: '',
  Values: [],
  AdditionalSearchKeys: [
    {
      KeyName: '',
      Values: ''
    }
  ],
  LogicalOperator: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/domains/:DomainName/profiles/search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/search',
  headers: {'content-type': 'application/json'},
  data: {
    KeyName: '',
    Values: [],
    AdditionalSearchKeys: [{KeyName: '', Values: ''}],
    LogicalOperator: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/profiles/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"KeyName":"","Values":[],"AdditionalSearchKeys":[{"KeyName":"","Values":""}],"LogicalOperator":""}'
};

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}}/domains/:DomainName/profiles/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "KeyName": "",\n  "Values": [],\n  "AdditionalSearchKeys": [\n    {\n      "KeyName": "",\n      "Values": ""\n    }\n  ],\n  "LogicalOperator": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles/search")
  .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/domains/:DomainName/profiles/search',
  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({
  KeyName: '',
  Values: [],
  AdditionalSearchKeys: [{KeyName: '', Values: ''}],
  LogicalOperator: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domains/:DomainName/profiles/search',
  headers: {'content-type': 'application/json'},
  body: {
    KeyName: '',
    Values: [],
    AdditionalSearchKeys: [{KeyName: '', Values: ''}],
    LogicalOperator: ''
  },
  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}}/domains/:DomainName/profiles/search');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  KeyName: '',
  Values: [],
  AdditionalSearchKeys: [
    {
      KeyName: '',
      Values: ''
    }
  ],
  LogicalOperator: ''
});

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}}/domains/:DomainName/profiles/search',
  headers: {'content-type': 'application/json'},
  data: {
    KeyName: '',
    Values: [],
    AdditionalSearchKeys: [{KeyName: '', Values: ''}],
    LogicalOperator: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/profiles/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"KeyName":"","Values":[],"AdditionalSearchKeys":[{"KeyName":"","Values":""}],"LogicalOperator":""}'
};

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 = @{ @"KeyName": @"",
                              @"Values": @[  ],
                              @"AdditionalSearchKeys": @[ @{ @"KeyName": @"", @"Values": @"" } ],
                              @"LogicalOperator": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles/search"]
                                                       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}}/domains/:DomainName/profiles/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/profiles/search",
  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([
    'KeyName' => '',
    'Values' => [
        
    ],
    'AdditionalSearchKeys' => [
        [
                'KeyName' => '',
                'Values' => ''
        ]
    ],
    'LogicalOperator' => ''
  ]),
  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}}/domains/:DomainName/profiles/search', [
  'body' => '{
  "KeyName": "",
  "Values": [],
  "AdditionalSearchKeys": [
    {
      "KeyName": "",
      "Values": ""
    }
  ],
  "LogicalOperator": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles/search');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'KeyName' => '',
  'Values' => [
    
  ],
  'AdditionalSearchKeys' => [
    [
        'KeyName' => '',
        'Values' => ''
    ]
  ],
  'LogicalOperator' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'KeyName' => '',
  'Values' => [
    
  ],
  'AdditionalSearchKeys' => [
    [
        'KeyName' => '',
        'Values' => ''
    ]
  ],
  'LogicalOperator' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles/search');
$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}}/domains/:DomainName/profiles/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "KeyName": "",
  "Values": [],
  "AdditionalSearchKeys": [
    {
      "KeyName": "",
      "Values": ""
    }
  ],
  "LogicalOperator": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "KeyName": "",
  "Values": [],
  "AdditionalSearchKeys": [
    {
      "KeyName": "",
      "Values": ""
    }
  ],
  "LogicalOperator": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/domains/:DomainName/profiles/search", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles/search"

payload = {
    "KeyName": "",
    "Values": [],
    "AdditionalSearchKeys": [
        {
            "KeyName": "",
            "Values": ""
        }
    ],
    "LogicalOperator": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles/search"

payload <- "{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\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}}/domains/:DomainName/profiles/search")

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  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\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/domains/:DomainName/profiles/search') do |req|
  req.body = "{\n  \"KeyName\": \"\",\n  \"Values\": [],\n  \"AdditionalSearchKeys\": [\n    {\n      \"KeyName\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"LogicalOperator\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/profiles/search";

    let payload = json!({
        "KeyName": "",
        "Values": (),
        "AdditionalSearchKeys": (
            json!({
                "KeyName": "",
                "Values": ""
            })
        ),
        "LogicalOperator": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "KeyName": "",
  "Values": [],
  "AdditionalSearchKeys": [
    {
      "KeyName": "",
      "Values": ""
    }
  ],
  "LogicalOperator": ""
}' |  \
  http POST {{baseUrl}}/domains/:DomainName/profiles/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "KeyName": "",\n  "Values": [],\n  "AdditionalSearchKeys": [\n    {\n      "KeyName": "",\n      "Values": ""\n    }\n  ],\n  "LogicalOperator": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "KeyName": "",
  "Values": [],
  "AdditionalSearchKeys": [
    [
      "KeyName": "",
      "Values": ""
    ]
  ],
  "LogicalOperator": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/profiles/search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

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  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/tags/:resourceArn" {:content-type :json
                                                              :form-params {:tags {}}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tags\": {}\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}}/tags/:resourceArn"),
    Content = new StringContent("{\n  \"tags\": {}\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}}/tags/:resourceArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

	payload := strings.NewReader("{\n  \"tags\": {}\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/tags/:resourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tags/:resourceArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"tags\": {}\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  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tags/:resourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/tags/:resourceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

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}}/tags/:resourceArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .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/tags/:resourceArn',
  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({tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  body: {tags: {}},
  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}}/tags/:resourceArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  tags: {}
});

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}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

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 = @{ @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn"]
                                                       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}}/tags/:resourceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn",
  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([
    'tags' => [
        
    ]
  ]),
  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}}/tags/:resourceArn', [
  'body' => '{
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$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}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/tags/:resourceArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn"

payload = { "tags": {} }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

payload <- "{\n  \"tags\": {}\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}}/tags/:resourceArn")

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  \"tags\": {}\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/tags/:resourceArn') do |req|
  req.body = "{\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn";

    let payload = json!({"tags": json!({})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "tags": {}
}' |  \
  http POST {{baseUrl}}/tags/:resourceArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["tags": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tags/:resourceArn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/tags/:resourceArn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn?tagKeys=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  qs: {tagKeys: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tags/:resourceArn#tagKeys');

req.query({
  tagKeys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'tagKeys' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'tagKeys' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/tags/:resourceArn?tagKeys=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn#tagKeys"

querystring = {"tagKeys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn#tagKeys"

queryString <- list(tagKeys = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/tags/:resourceArn') do |req|
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn#tagKeys";

    let querystring = [
        ("tagKeys", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName");

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  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/domains/:DomainName" {:content-type :json
                                                               :form-params {:DefaultExpirationDays 0
                                                                             :DefaultEncryptionKey ""
                                                                             :DeadLetterQueueUrl ""
                                                                             :Matching {:Enabled ""
                                                                                        :JobSchedule ""
                                                                                        :AutoMerging ""
                                                                                        :ExportingConfig ""}
                                                                             :Tags {}}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName"),
    Content = new StringContent("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\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}}/domains/:DomainName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName"

	payload := strings.NewReader("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/domains/:DomainName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 216

{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/domains/:DomainName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\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  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/domains/:DomainName")
  .header("content-type", "application/json")
  .body("{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  DefaultExpirationDays: 0,
  DefaultEncryptionKey: '',
  DeadLetterQueueUrl: '',
  Matching: {
    Enabled: '',
    JobSchedule: '',
    AutoMerging: '',
    ExportingConfig: ''
  },
  Tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/domains/:DomainName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultExpirationDays: 0,
    DefaultEncryptionKey: '',
    DeadLetterQueueUrl: '',
    Matching: {Enabled: '', JobSchedule: '', AutoMerging: '', ExportingConfig: ''},
    Tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultExpirationDays":0,"DefaultEncryptionKey":"","DeadLetterQueueUrl":"","Matching":{"Enabled":"","JobSchedule":"","AutoMerging":"","ExportingConfig":""},"Tags":{}}'
};

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}}/domains/:DomainName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DefaultExpirationDays": 0,\n  "DefaultEncryptionKey": "",\n  "DeadLetterQueueUrl": "",\n  "Matching": {\n    "Enabled": "",\n    "JobSchedule": "",\n    "AutoMerging": "",\n    "ExportingConfig": ""\n  },\n  "Tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName',
  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({
  DefaultExpirationDays: 0,
  DefaultEncryptionKey: '',
  DeadLetterQueueUrl: '',
  Matching: {Enabled: '', JobSchedule: '', AutoMerging: '', ExportingConfig: ''},
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName',
  headers: {'content-type': 'application/json'},
  body: {
    DefaultExpirationDays: 0,
    DefaultEncryptionKey: '',
    DeadLetterQueueUrl: '',
    Matching: {Enabled: '', JobSchedule: '', AutoMerging: '', ExportingConfig: ''},
    Tags: {}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/domains/:DomainName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DefaultExpirationDays: 0,
  DefaultEncryptionKey: '',
  DeadLetterQueueUrl: '',
  Matching: {
    Enabled: '',
    JobSchedule: '',
    AutoMerging: '',
    ExportingConfig: ''
  },
  Tags: {}
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultExpirationDays: 0,
    DefaultEncryptionKey: '',
    DeadLetterQueueUrl: '',
    Matching: {Enabled: '', JobSchedule: '', AutoMerging: '', ExportingConfig: ''},
    Tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultExpirationDays":0,"DefaultEncryptionKey":"","DeadLetterQueueUrl":"","Matching":{"Enabled":"","JobSchedule":"","AutoMerging":"","ExportingConfig":""},"Tags":{}}'
};

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 = @{ @"DefaultExpirationDays": @0,
                              @"DefaultEncryptionKey": @"",
                              @"DeadLetterQueueUrl": @"",
                              @"Matching": @{ @"Enabled": @"", @"JobSchedule": @"", @"AutoMerging": @"", @"ExportingConfig": @"" },
                              @"Tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'DefaultExpirationDays' => 0,
    'DefaultEncryptionKey' => '',
    'DeadLetterQueueUrl' => '',
    'Matching' => [
        'Enabled' => '',
        'JobSchedule' => '',
        'AutoMerging' => '',
        'ExportingConfig' => ''
    ],
    'Tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/domains/:DomainName', [
  'body' => '{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DefaultExpirationDays' => 0,
  'DefaultEncryptionKey' => '',
  'DeadLetterQueueUrl' => '',
  'Matching' => [
    'Enabled' => '',
    'JobSchedule' => '',
    'AutoMerging' => '',
    'ExportingConfig' => ''
  ],
  'Tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DefaultExpirationDays' => 0,
  'DefaultEncryptionKey' => '',
  'DeadLetterQueueUrl' => '',
  'Matching' => [
    'Enabled' => '',
    'JobSchedule' => '',
    'AutoMerging' => '',
    'ExportingConfig' => ''
  ],
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/domains/:DomainName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName"

payload = {
    "DefaultExpirationDays": 0,
    "DefaultEncryptionKey": "",
    "DeadLetterQueueUrl": "",
    "Matching": {
        "Enabled": "",
        "JobSchedule": "",
        "AutoMerging": "",
        "ExportingConfig": ""
    },
    "Tags": {}
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName"

payload <- "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/domains/:DomainName') do |req|
  req.body = "{\n  \"DefaultExpirationDays\": 0,\n  \"DefaultEncryptionKey\": \"\",\n  \"DeadLetterQueueUrl\": \"\",\n  \"Matching\": {\n    \"Enabled\": \"\",\n    \"JobSchedule\": \"\",\n    \"AutoMerging\": \"\",\n    \"ExportingConfig\": \"\"\n  },\n  \"Tags\": {}\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName";

    let payload = json!({
        "DefaultExpirationDays": 0,
        "DefaultEncryptionKey": "",
        "DeadLetterQueueUrl": "",
        "Matching": json!({
            "Enabled": "",
            "JobSchedule": "",
            "AutoMerging": "",
            "ExportingConfig": ""
        }),
        "Tags": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": {
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  },
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/domains/:DomainName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "DefaultExpirationDays": 0,\n  "DefaultEncryptionKey": "",\n  "DeadLetterQueueUrl": "",\n  "Matching": {\n    "Enabled": "",\n    "JobSchedule": "",\n    "AutoMerging": "",\n    "ExportingConfig": ""\n  },\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DefaultExpirationDays": 0,
  "DefaultEncryptionKey": "",
  "DeadLetterQueueUrl": "",
  "Matching": [
    "Enabled": "",
    "JobSchedule": "",
    "AutoMerging": "",
    "ExportingConfig": ""
  ],
  "Tags": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:DomainName/profiles");

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  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/domains/:DomainName/profiles" {:content-type :json
                                                                        :form-params {:ProfileId ""
                                                                                      :AdditionalInformation ""
                                                                                      :AccountNumber ""
                                                                                      :PartyType ""
                                                                                      :BusinessName ""
                                                                                      :FirstName ""
                                                                                      :MiddleName ""
                                                                                      :LastName ""
                                                                                      :BirthDate ""
                                                                                      :Gender ""
                                                                                      :PhoneNumber ""
                                                                                      :MobilePhoneNumber ""
                                                                                      :HomePhoneNumber ""
                                                                                      :BusinessPhoneNumber ""
                                                                                      :EmailAddress ""
                                                                                      :PersonalEmailAddress ""
                                                                                      :BusinessEmailAddress ""
                                                                                      :Address {:Address1 ""
                                                                                                :Address2 ""
                                                                                                :Address3 ""
                                                                                                :Address4 ""
                                                                                                :City ""
                                                                                                :County ""
                                                                                                :State ""
                                                                                                :Province ""
                                                                                                :Country ""
                                                                                                :PostalCode ""}
                                                                                      :ShippingAddress {:Address1 ""
                                                                                                        :Address2 ""
                                                                                                        :Address3 ""
                                                                                                        :Address4 ""
                                                                                                        :City ""
                                                                                                        :County ""
                                                                                                        :State ""
                                                                                                        :Province ""
                                                                                                        :Country ""
                                                                                                        :PostalCode ""}
                                                                                      :MailingAddress {:Address1 ""
                                                                                                       :Address2 ""
                                                                                                       :Address3 ""
                                                                                                       :Address4 ""
                                                                                                       :City ""
                                                                                                       :County ""
                                                                                                       :State ""
                                                                                                       :Province ""
                                                                                                       :Country ""
                                                                                                       :PostalCode ""}
                                                                                      :BillingAddress {:Address1 ""
                                                                                                       :Address2 ""
                                                                                                       :Address3 ""
                                                                                                       :Address4 ""
                                                                                                       :City ""
                                                                                                       :County ""
                                                                                                       :State ""
                                                                                                       :Province ""
                                                                                                       :Country ""
                                                                                                       :PostalCode ""}
                                                                                      :Attributes {}
                                                                                      :PartyTypeString ""
                                                                                      :GenderString ""}})

require "http/client"

url = "{{baseUrl}}/domains/:DomainName/profiles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/domains/:DomainName/profiles"),
    Content = new StringContent("{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\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}}/domains/:DomainName/profiles");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domains/:DomainName/profiles"

	payload := strings.NewReader("{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/domains/:DomainName/profiles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1325

{
  "ProfileId": "",
  "AdditionalInformation": "",
  "AccountNumber": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/domains/:DomainName/profiles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domains/:DomainName/profiles"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\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  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/domains/:DomainName/profiles")
  .header("content-type", "application/json")
  .body("{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ProfileId: '',
  AdditionalInformation: '',
  AccountNumber: '',
  PartyType: '',
  BusinessName: '',
  FirstName: '',
  MiddleName: '',
  LastName: '',
  BirthDate: '',
  Gender: '',
  PhoneNumber: '',
  MobilePhoneNumber: '',
  HomePhoneNumber: '',
  BusinessPhoneNumber: '',
  EmailAddress: '',
  PersonalEmailAddress: '',
  BusinessEmailAddress: '',
  Address: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  ShippingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  MailingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  BillingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  Attributes: {},
  PartyTypeString: '',
  GenderString: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/domains/:DomainName/profiles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/profiles',
  headers: {'content-type': 'application/json'},
  data: {
    ProfileId: '',
    AdditionalInformation: '',
    AccountNumber: '',
    PartyType: '',
    BusinessName: '',
    FirstName: '',
    MiddleName: '',
    LastName: '',
    BirthDate: '',
    Gender: '',
    PhoneNumber: '',
    MobilePhoneNumber: '',
    HomePhoneNumber: '',
    BusinessPhoneNumber: '',
    EmailAddress: '',
    PersonalEmailAddress: '',
    BusinessEmailAddress: '',
    Address: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    ShippingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    MailingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    BillingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    Attributes: {},
    PartyTypeString: '',
    GenderString: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domains/:DomainName/profiles';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":"","AdditionalInformation":"","AccountNumber":"","PartyType":"","BusinessName":"","FirstName":"","MiddleName":"","LastName":"","BirthDate":"","Gender":"","PhoneNumber":"","MobilePhoneNumber":"","HomePhoneNumber":"","BusinessPhoneNumber":"","EmailAddress":"","PersonalEmailAddress":"","BusinessEmailAddress":"","Address":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"ShippingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"MailingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"BillingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"Attributes":{},"PartyTypeString":"","GenderString":""}'
};

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}}/domains/:DomainName/profiles',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProfileId": "",\n  "AdditionalInformation": "",\n  "AccountNumber": "",\n  "PartyType": "",\n  "BusinessName": "",\n  "FirstName": "",\n  "MiddleName": "",\n  "LastName": "",\n  "BirthDate": "",\n  "Gender": "",\n  "PhoneNumber": "",\n  "MobilePhoneNumber": "",\n  "HomePhoneNumber": "",\n  "BusinessPhoneNumber": "",\n  "EmailAddress": "",\n  "PersonalEmailAddress": "",\n  "BusinessEmailAddress": "",\n  "Address": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "ShippingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "MailingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "BillingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "Attributes": {},\n  "PartyTypeString": "",\n  "GenderString": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domains/:DomainName/profiles")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domains/:DomainName/profiles',
  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({
  ProfileId: '',
  AdditionalInformation: '',
  AccountNumber: '',
  PartyType: '',
  BusinessName: '',
  FirstName: '',
  MiddleName: '',
  LastName: '',
  BirthDate: '',
  Gender: '',
  PhoneNumber: '',
  MobilePhoneNumber: '',
  HomePhoneNumber: '',
  BusinessPhoneNumber: '',
  EmailAddress: '',
  PersonalEmailAddress: '',
  BusinessEmailAddress: '',
  Address: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  ShippingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  MailingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  BillingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  Attributes: {},
  PartyTypeString: '',
  GenderString: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/profiles',
  headers: {'content-type': 'application/json'},
  body: {
    ProfileId: '',
    AdditionalInformation: '',
    AccountNumber: '',
    PartyType: '',
    BusinessName: '',
    FirstName: '',
    MiddleName: '',
    LastName: '',
    BirthDate: '',
    Gender: '',
    PhoneNumber: '',
    MobilePhoneNumber: '',
    HomePhoneNumber: '',
    BusinessPhoneNumber: '',
    EmailAddress: '',
    PersonalEmailAddress: '',
    BusinessEmailAddress: '',
    Address: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    ShippingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    MailingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    BillingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    Attributes: {},
    PartyTypeString: '',
    GenderString: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/domains/:DomainName/profiles');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ProfileId: '',
  AdditionalInformation: '',
  AccountNumber: '',
  PartyType: '',
  BusinessName: '',
  FirstName: '',
  MiddleName: '',
  LastName: '',
  BirthDate: '',
  Gender: '',
  PhoneNumber: '',
  MobilePhoneNumber: '',
  HomePhoneNumber: '',
  BusinessPhoneNumber: '',
  EmailAddress: '',
  PersonalEmailAddress: '',
  BusinessEmailAddress: '',
  Address: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  ShippingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  MailingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  BillingAddress: {
    Address1: '',
    Address2: '',
    Address3: '',
    Address4: '',
    City: '',
    County: '',
    State: '',
    Province: '',
    Country: '',
    PostalCode: ''
  },
  Attributes: {},
  PartyTypeString: '',
  GenderString: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/domains/:DomainName/profiles',
  headers: {'content-type': 'application/json'},
  data: {
    ProfileId: '',
    AdditionalInformation: '',
    AccountNumber: '',
    PartyType: '',
    BusinessName: '',
    FirstName: '',
    MiddleName: '',
    LastName: '',
    BirthDate: '',
    Gender: '',
    PhoneNumber: '',
    MobilePhoneNumber: '',
    HomePhoneNumber: '',
    BusinessPhoneNumber: '',
    EmailAddress: '',
    PersonalEmailAddress: '',
    BusinessEmailAddress: '',
    Address: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    ShippingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    MailingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    BillingAddress: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      City: '',
      County: '',
      State: '',
      Province: '',
      Country: '',
      PostalCode: ''
    },
    Attributes: {},
    PartyTypeString: '',
    GenderString: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domains/:DomainName/profiles';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ProfileId":"","AdditionalInformation":"","AccountNumber":"","PartyType":"","BusinessName":"","FirstName":"","MiddleName":"","LastName":"","BirthDate":"","Gender":"","PhoneNumber":"","MobilePhoneNumber":"","HomePhoneNumber":"","BusinessPhoneNumber":"","EmailAddress":"","PersonalEmailAddress":"","BusinessEmailAddress":"","Address":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"ShippingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"MailingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"BillingAddress":{"Address1":"","Address2":"","Address3":"","Address4":"","City":"","County":"","State":"","Province":"","Country":"","PostalCode":""},"Attributes":{},"PartyTypeString":"","GenderString":""}'
};

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 = @{ @"ProfileId": @"",
                              @"AdditionalInformation": @"",
                              @"AccountNumber": @"",
                              @"PartyType": @"",
                              @"BusinessName": @"",
                              @"FirstName": @"",
                              @"MiddleName": @"",
                              @"LastName": @"",
                              @"BirthDate": @"",
                              @"Gender": @"",
                              @"PhoneNumber": @"",
                              @"MobilePhoneNumber": @"",
                              @"HomePhoneNumber": @"",
                              @"BusinessPhoneNumber": @"",
                              @"EmailAddress": @"",
                              @"PersonalEmailAddress": @"",
                              @"BusinessEmailAddress": @"",
                              @"Address": @{ @"Address1": @"", @"Address2": @"", @"Address3": @"", @"Address4": @"", @"City": @"", @"County": @"", @"State": @"", @"Province": @"", @"Country": @"", @"PostalCode": @"" },
                              @"ShippingAddress": @{ @"Address1": @"", @"Address2": @"", @"Address3": @"", @"Address4": @"", @"City": @"", @"County": @"", @"State": @"", @"Province": @"", @"Country": @"", @"PostalCode": @"" },
                              @"MailingAddress": @{ @"Address1": @"", @"Address2": @"", @"Address3": @"", @"Address4": @"", @"City": @"", @"County": @"", @"State": @"", @"Province": @"", @"Country": @"", @"PostalCode": @"" },
                              @"BillingAddress": @{ @"Address1": @"", @"Address2": @"", @"Address3": @"", @"Address4": @"", @"City": @"", @"County": @"", @"State": @"", @"Province": @"", @"Country": @"", @"PostalCode": @"" },
                              @"Attributes": @{  },
                              @"PartyTypeString": @"",
                              @"GenderString": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:DomainName/profiles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domains/:DomainName/profiles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domains/:DomainName/profiles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'ProfileId' => '',
    'AdditionalInformation' => '',
    'AccountNumber' => '',
    'PartyType' => '',
    'BusinessName' => '',
    'FirstName' => '',
    'MiddleName' => '',
    'LastName' => '',
    'BirthDate' => '',
    'Gender' => '',
    'PhoneNumber' => '',
    'MobilePhoneNumber' => '',
    'HomePhoneNumber' => '',
    'BusinessPhoneNumber' => '',
    'EmailAddress' => '',
    'PersonalEmailAddress' => '',
    'BusinessEmailAddress' => '',
    'Address' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'City' => '',
        'County' => '',
        'State' => '',
        'Province' => '',
        'Country' => '',
        'PostalCode' => ''
    ],
    'ShippingAddress' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'City' => '',
        'County' => '',
        'State' => '',
        'Province' => '',
        'Country' => '',
        'PostalCode' => ''
    ],
    'MailingAddress' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'City' => '',
        'County' => '',
        'State' => '',
        'Province' => '',
        'Country' => '',
        'PostalCode' => ''
    ],
    'BillingAddress' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'City' => '',
        'County' => '',
        'State' => '',
        'Province' => '',
        'Country' => '',
        'PostalCode' => ''
    ],
    'Attributes' => [
        
    ],
    'PartyTypeString' => '',
    'GenderString' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/domains/:DomainName/profiles', [
  'body' => '{
  "ProfileId": "",
  "AdditionalInformation": "",
  "AccountNumber": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domains/:DomainName/profiles');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProfileId' => '',
  'AdditionalInformation' => '',
  'AccountNumber' => '',
  'PartyType' => '',
  'BusinessName' => '',
  'FirstName' => '',
  'MiddleName' => '',
  'LastName' => '',
  'BirthDate' => '',
  'Gender' => '',
  'PhoneNumber' => '',
  'MobilePhoneNumber' => '',
  'HomePhoneNumber' => '',
  'BusinessPhoneNumber' => '',
  'EmailAddress' => '',
  'PersonalEmailAddress' => '',
  'BusinessEmailAddress' => '',
  'Address' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'ShippingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'MailingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'BillingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'Attributes' => [
    
  ],
  'PartyTypeString' => '',
  'GenderString' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ProfileId' => '',
  'AdditionalInformation' => '',
  'AccountNumber' => '',
  'PartyType' => '',
  'BusinessName' => '',
  'FirstName' => '',
  'MiddleName' => '',
  'LastName' => '',
  'BirthDate' => '',
  'Gender' => '',
  'PhoneNumber' => '',
  'MobilePhoneNumber' => '',
  'HomePhoneNumber' => '',
  'BusinessPhoneNumber' => '',
  'EmailAddress' => '',
  'PersonalEmailAddress' => '',
  'BusinessEmailAddress' => '',
  'Address' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'ShippingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'MailingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'BillingAddress' => [
    'Address1' => '',
    'Address2' => '',
    'Address3' => '',
    'Address4' => '',
    'City' => '',
    'County' => '',
    'State' => '',
    'Province' => '',
    'Country' => '',
    'PostalCode' => ''
  ],
  'Attributes' => [
    
  ],
  'PartyTypeString' => '',
  'GenderString' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domains/:DomainName/profiles');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:DomainName/profiles' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": "",
  "AdditionalInformation": "",
  "AccountNumber": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:DomainName/profiles' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ProfileId": "",
  "AdditionalInformation": "",
  "AccountNumber": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/domains/:DomainName/profiles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domains/:DomainName/profiles"

payload = {
    "ProfileId": "",
    "AdditionalInformation": "",
    "AccountNumber": "",
    "PartyType": "",
    "BusinessName": "",
    "FirstName": "",
    "MiddleName": "",
    "LastName": "",
    "BirthDate": "",
    "Gender": "",
    "PhoneNumber": "",
    "MobilePhoneNumber": "",
    "HomePhoneNumber": "",
    "BusinessPhoneNumber": "",
    "EmailAddress": "",
    "PersonalEmailAddress": "",
    "BusinessEmailAddress": "",
    "Address": {
        "Address1": "",
        "Address2": "",
        "Address3": "",
        "Address4": "",
        "City": "",
        "County": "",
        "State": "",
        "Province": "",
        "Country": "",
        "PostalCode": ""
    },
    "ShippingAddress": {
        "Address1": "",
        "Address2": "",
        "Address3": "",
        "Address4": "",
        "City": "",
        "County": "",
        "State": "",
        "Province": "",
        "Country": "",
        "PostalCode": ""
    },
    "MailingAddress": {
        "Address1": "",
        "Address2": "",
        "Address3": "",
        "Address4": "",
        "City": "",
        "County": "",
        "State": "",
        "Province": "",
        "Country": "",
        "PostalCode": ""
    },
    "BillingAddress": {
        "Address1": "",
        "Address2": "",
        "Address3": "",
        "Address4": "",
        "City": "",
        "County": "",
        "State": "",
        "Province": "",
        "Country": "",
        "PostalCode": ""
    },
    "Attributes": {},
    "PartyTypeString": "",
    "GenderString": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domains/:DomainName/profiles"

payload <- "{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domains/:DomainName/profiles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/domains/:DomainName/profiles') do |req|
  req.body = "{\n  \"ProfileId\": \"\",\n  \"AdditionalInformation\": \"\",\n  \"AccountNumber\": \"\",\n  \"PartyType\": \"\",\n  \"BusinessName\": \"\",\n  \"FirstName\": \"\",\n  \"MiddleName\": \"\",\n  \"LastName\": \"\",\n  \"BirthDate\": \"\",\n  \"Gender\": \"\",\n  \"PhoneNumber\": \"\",\n  \"MobilePhoneNumber\": \"\",\n  \"HomePhoneNumber\": \"\",\n  \"BusinessPhoneNumber\": \"\",\n  \"EmailAddress\": \"\",\n  \"PersonalEmailAddress\": \"\",\n  \"BusinessEmailAddress\": \"\",\n  \"Address\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"MailingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"BillingAddress\": {\n    \"Address1\": \"\",\n    \"Address2\": \"\",\n    \"Address3\": \"\",\n    \"Address4\": \"\",\n    \"City\": \"\",\n    \"County\": \"\",\n    \"State\": \"\",\n    \"Province\": \"\",\n    \"Country\": \"\",\n    \"PostalCode\": \"\"\n  },\n  \"Attributes\": {},\n  \"PartyTypeString\": \"\",\n  \"GenderString\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domains/:DomainName/profiles";

    let payload = json!({
        "ProfileId": "",
        "AdditionalInformation": "",
        "AccountNumber": "",
        "PartyType": "",
        "BusinessName": "",
        "FirstName": "",
        "MiddleName": "",
        "LastName": "",
        "BirthDate": "",
        "Gender": "",
        "PhoneNumber": "",
        "MobilePhoneNumber": "",
        "HomePhoneNumber": "",
        "BusinessPhoneNumber": "",
        "EmailAddress": "",
        "PersonalEmailAddress": "",
        "BusinessEmailAddress": "",
        "Address": json!({
            "Address1": "",
            "Address2": "",
            "Address3": "",
            "Address4": "",
            "City": "",
            "County": "",
            "State": "",
            "Province": "",
            "Country": "",
            "PostalCode": ""
        }),
        "ShippingAddress": json!({
            "Address1": "",
            "Address2": "",
            "Address3": "",
            "Address4": "",
            "City": "",
            "County": "",
            "State": "",
            "Province": "",
            "Country": "",
            "PostalCode": ""
        }),
        "MailingAddress": json!({
            "Address1": "",
            "Address2": "",
            "Address3": "",
            "Address4": "",
            "City": "",
            "County": "",
            "State": "",
            "Province": "",
            "Country": "",
            "PostalCode": ""
        }),
        "BillingAddress": json!({
            "Address1": "",
            "Address2": "",
            "Address3": "",
            "Address4": "",
            "City": "",
            "County": "",
            "State": "",
            "Province": "",
            "Country": "",
            "PostalCode": ""
        }),
        "Attributes": json!({}),
        "PartyTypeString": "",
        "GenderString": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "ProfileId": "",
  "AdditionalInformation": "",
  "AccountNumber": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "ShippingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "MailingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "BillingAddress": {
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  },
  "Attributes": {},
  "PartyTypeString": "",
  "GenderString": ""
}' |  \
  http PUT {{baseUrl}}/domains/:DomainName/profiles \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProfileId": "",\n  "AdditionalInformation": "",\n  "AccountNumber": "",\n  "PartyType": "",\n  "BusinessName": "",\n  "FirstName": "",\n  "MiddleName": "",\n  "LastName": "",\n  "BirthDate": "",\n  "Gender": "",\n  "PhoneNumber": "",\n  "MobilePhoneNumber": "",\n  "HomePhoneNumber": "",\n  "BusinessPhoneNumber": "",\n  "EmailAddress": "",\n  "PersonalEmailAddress": "",\n  "BusinessEmailAddress": "",\n  "Address": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "ShippingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "MailingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "BillingAddress": {\n    "Address1": "",\n    "Address2": "",\n    "Address3": "",\n    "Address4": "",\n    "City": "",\n    "County": "",\n    "State": "",\n    "Province": "",\n    "Country": "",\n    "PostalCode": ""\n  },\n  "Attributes": {},\n  "PartyTypeString": "",\n  "GenderString": ""\n}' \
  --output-document \
  - {{baseUrl}}/domains/:DomainName/profiles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ProfileId": "",
  "AdditionalInformation": "",
  "AccountNumber": "",
  "PartyType": "",
  "BusinessName": "",
  "FirstName": "",
  "MiddleName": "",
  "LastName": "",
  "BirthDate": "",
  "Gender": "",
  "PhoneNumber": "",
  "MobilePhoneNumber": "",
  "HomePhoneNumber": "",
  "BusinessPhoneNumber": "",
  "EmailAddress": "",
  "PersonalEmailAddress": "",
  "BusinessEmailAddress": "",
  "Address": [
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  ],
  "ShippingAddress": [
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  ],
  "MailingAddress": [
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  ],
  "BillingAddress": [
    "Address1": "",
    "Address2": "",
    "Address3": "",
    "Address4": "",
    "City": "",
    "County": "",
    "State": "",
    "Province": "",
    "Country": "",
    "PostalCode": ""
  ],
  "Attributes": [],
  "PartyTypeString": "",
  "GenderString": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:DomainName/profiles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()