CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/instance/:InstanceId/approved-origin");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance/:InstanceId/approved-origin" {:content-type :json
                                                                                :form-params {:Origin ""}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/approved-origin"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Origin\": \"\"\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}}/instance/:InstanceId/approved-origin"),
    Content = new StringContent("{\n  \"Origin\": \"\"\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}}/instance/:InstanceId/approved-origin");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Origin\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/approved-origin"

	payload := strings.NewReader("{\n  \"Origin\": \"\"\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/instance/:InstanceId/approved-origin HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "Origin": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance/:InstanceId/approved-origin")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Origin\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/approved-origin"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Origin\": \"\"\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  \"Origin\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/approved-origin")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance/:InstanceId/approved-origin")
  .header("content-type", "application/json")
  .body("{\n  \"Origin\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/instance/:InstanceId/approved-origin');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/approved-origin',
  headers: {'content-type': 'application/json'},
  data: {Origin: ''}
};

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

const url = '{{baseUrl}}/instance/:InstanceId/approved-origin';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Origin":""}'
};

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}}/instance/:InstanceId/approved-origin',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Origin": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Origin\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/approved-origin")
  .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/instance/:InstanceId/approved-origin',
  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({Origin: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/approved-origin',
  headers: {'content-type': 'application/json'},
  body: {Origin: ''},
  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}}/instance/:InstanceId/approved-origin');

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

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

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}}/instance/:InstanceId/approved-origin',
  headers: {'content-type': 'application/json'},
  data: {Origin: ''}
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/approved-origin';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Origin":""}'
};

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

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

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

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

 "{{baseUrl}}/instance/:InstanceId/approved-origin",
  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([
    'Origin' => ''
  ]),
  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}}/instance/:InstanceId/approved-origin', [
  'body' => '{
  "Origin": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/approved-origin');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'Origin' => ''
]));
$request->setRequestUrl('{{baseUrl}}/instance/:InstanceId/approved-origin');
$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}}/instance/:InstanceId/approved-origin' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Origin": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/approved-origin' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Origin": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/instance/:InstanceId/approved-origin", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/approved-origin"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/approved-origin"

payload <- "{\n  \"Origin\": \"\"\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}}/instance/:InstanceId/approved-origin")

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  \"Origin\": \"\"\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/instance/:InstanceId/approved-origin') do |req|
  req.body = "{\n  \"Origin\": \"\"\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}}/instance/:InstanceId/approved-origin";

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

    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 '{
  "Origin": ""
}' |  \
  http PUT {{baseUrl}}/instance/:InstanceId/approved-origin \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Origin": ""\n}' \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/approved-origin

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/approved-origin")! 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}}/instance/:InstanceId/bot");

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  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance/:InstanceId/bot" {:content-type :json
                                                                    :form-params {:LexBot {:Name ""
                                                                                           :LexRegion ""}
                                                                                  :LexV2Bot {:AliasArn ""}}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/bot"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/instance/:InstanceId/bot"),
    Content = new StringContent("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\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}}/instance/:InstanceId/bot");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/bot"

	payload := strings.NewReader("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\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/instance/:InstanceId/bot HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 97

{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  },
  "LexV2Bot": {
    "AliasArn": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance/:InstanceId/bot")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/bot"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\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  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/bot")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance/:InstanceId/bot")
  .header("content-type", "application/json")
  .body("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  LexBot: {
    Name: '',
    LexRegion: ''
  },
  LexV2Bot: {
    AliasArn: ''
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/instance/:InstanceId/bot');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/bot',
  headers: {'content-type': 'application/json'},
  data: {LexBot: {Name: '', LexRegion: ''}, LexV2Bot: {AliasArn: ''}}
};

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

const url = '{{baseUrl}}/instance/:InstanceId/bot';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LexBot":{"Name":"","LexRegion":""},"LexV2Bot":{"AliasArn":""}}'
};

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}}/instance/:InstanceId/bot',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LexBot": {\n    "Name": "",\n    "LexRegion": ""\n  },\n  "LexV2Bot": {\n    "AliasArn": ""\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  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/bot")
  .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/instance/:InstanceId/bot',
  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({LexBot: {Name: '', LexRegion: ''}, LexV2Bot: {AliasArn: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/bot',
  headers: {'content-type': 'application/json'},
  body: {LexBot: {Name: '', LexRegion: ''}, LexV2Bot: {AliasArn: ''}},
  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}}/instance/:InstanceId/bot');

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

req.type('json');
req.send({
  LexBot: {
    Name: '',
    LexRegion: ''
  },
  LexV2Bot: {
    AliasArn: ''
  }
});

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}}/instance/:InstanceId/bot',
  headers: {'content-type': 'application/json'},
  data: {LexBot: {Name: '', LexRegion: ''}, LexV2Bot: {AliasArn: ''}}
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/bot';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LexBot":{"Name":"","LexRegion":""},"LexV2Bot":{"AliasArn":""}}'
};

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 = @{ @"LexBot": @{ @"Name": @"", @"LexRegion": @"" },
                              @"LexV2Bot": @{ @"AliasArn": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/instance/:InstanceId/bot"]
                                                       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}}/instance/:InstanceId/bot" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/instance/:InstanceId/bot",
  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([
    'LexBot' => [
        'Name' => '',
        'LexRegion' => ''
    ],
    'LexV2Bot' => [
        'AliasArn' => ''
    ]
  ]),
  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}}/instance/:InstanceId/bot', [
  'body' => '{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  },
  "LexV2Bot": {
    "AliasArn": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/bot');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LexBot' => [
    'Name' => '',
    'LexRegion' => ''
  ],
  'LexV2Bot' => [
    'AliasArn' => ''
  ]
]));

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

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

append(json_encode([
  'LexBot' => [
    'Name' => '',
    'LexRegion' => ''
  ],
  'LexV2Bot' => [
    'AliasArn' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/instance/:InstanceId/bot');
$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}}/instance/:InstanceId/bot' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  },
  "LexV2Bot": {
    "AliasArn": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/bot' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  },
  "LexV2Bot": {
    "AliasArn": ""
  }
}'

import http.client

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

payload = "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}"

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

conn.request("PUT", "/baseUrl/instance/:InstanceId/bot", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/bot"

payload = {
    "LexBot": {
        "Name": "",
        "LexRegion": ""
    },
    "LexV2Bot": { "AliasArn": "" }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/bot"

payload <- "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId/bot")

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  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/instance/:InstanceId/bot') do |req|
  req.body = "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  },\n  \"LexV2Bot\": {\n    \"AliasArn\": \"\"\n  }\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "LexBot": json!({
            "Name": "",
            "LexRegion": ""
        }),
        "LexV2Bot": json!({"AliasArn": ""})
    });

    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 '{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  },
  "LexV2Bot": {
    "AliasArn": ""
  }
}' |  \
  http PUT {{baseUrl}}/instance/:InstanceId/bot \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "LexBot": {\n    "Name": "",\n    "LexRegion": ""\n  },\n  "LexV2Bot": {\n    "AliasArn": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/bot

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "LexBot": [
    "Name": "",
    "LexRegion": ""
  ],
  "LexV2Bot": ["AliasArn": ""]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/bot")! 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}}/default-vocabulary/:InstanceId/:LanguageCode");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode" {:content-type :json
                                                                                        :form-params {:VocabularyId ""}})

require "http/client"

url = "{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"VocabularyId\": \"\"\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}}/default-vocabulary/:InstanceId/:LanguageCode"),
    Content = new StringContent("{\n  \"VocabularyId\": \"\"\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}}/default-vocabulary/:InstanceId/:LanguageCode");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VocabularyId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode"

	payload := strings.NewReader("{\n  \"VocabularyId\": \"\"\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/default-vocabulary/:InstanceId/:LanguageCode HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24

{
  "VocabularyId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VocabularyId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"VocabularyId\": \"\"\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  \"VocabularyId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode")
  .header("content-type", "application/json")
  .body("{\n  \"VocabularyId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode',
  headers: {'content-type': 'application/json'},
  data: {VocabularyId: ''}
};

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

const url = '{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"VocabularyId":""}'
};

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}}/default-vocabulary/:InstanceId/:LanguageCode',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VocabularyId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VocabularyId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode")
  .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/default-vocabulary/:InstanceId/:LanguageCode',
  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({VocabularyId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode',
  headers: {'content-type': 'application/json'},
  body: {VocabularyId: ''},
  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}}/default-vocabulary/:InstanceId/:LanguageCode');

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

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

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}}/default-vocabulary/:InstanceId/:LanguageCode',
  headers: {'content-type': 'application/json'},
  data: {VocabularyId: ''}
};

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

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

const url = '{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"VocabularyId":""}'
};

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

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

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

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

 "{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode",
  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([
    'VocabularyId' => ''
  ]),
  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}}/default-vocabulary/:InstanceId/:LanguageCode', [
  'body' => '{
  "VocabularyId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'VocabularyId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode');
$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}}/default-vocabulary/:InstanceId/:LanguageCode' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "VocabularyId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "VocabularyId": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/default-vocabulary/:InstanceId/:LanguageCode", payload, headers)

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

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

import requests

url = "{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode"

payload <- "{\n  \"VocabularyId\": \"\"\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}}/default-vocabulary/:InstanceId/:LanguageCode")

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  \"VocabularyId\": \"\"\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/default-vocabulary/:InstanceId/:LanguageCode') do |req|
  req.body = "{\n  \"VocabularyId\": \"\"\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}}/default-vocabulary/:InstanceId/:LanguageCode";

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

    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 '{
  "VocabularyId": ""
}' |  \
  http PUT {{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "VocabularyId": ""\n}' \
  --output-document \
  - {{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/default-vocabulary/:InstanceId/:LanguageCode")! 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}}/instance/:InstanceId/storage-config");

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  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance/:InstanceId/storage-config" {:content-type :json
                                                                               :form-params {:ResourceType ""
                                                                                             :StorageConfig {:AssociationId ""
                                                                                                             :StorageType ""
                                                                                                             :S3Config ""
                                                                                                             :KinesisVideoStreamConfig ""
                                                                                                             :KinesisStreamConfig ""
                                                                                                             :KinesisFirehoseConfig ""}}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/storage-config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/instance/:InstanceId/storage-config"),
    Content = new StringContent("{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\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}}/instance/:InstanceId/storage-config");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/storage-config"

	payload := strings.NewReader("{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\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/instance/:InstanceId/storage-config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 217

{
  "ResourceType": "",
  "StorageConfig": {
    "AssociationId": "",
    "StorageType": "",
    "S3Config": "",
    "KinesisVideoStreamConfig": "",
    "KinesisStreamConfig": "",
    "KinesisFirehoseConfig": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance/:InstanceId/storage-config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/storage-config"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\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  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/storage-config")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance/:InstanceId/storage-config")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  ResourceType: '',
  StorageConfig: {
    AssociationId: '',
    StorageType: '',
    S3Config: '',
    KinesisVideoStreamConfig: '',
    KinesisStreamConfig: '',
    KinesisFirehoseConfig: ''
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/instance/:InstanceId/storage-config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/storage-config',
  headers: {'content-type': 'application/json'},
  data: {
    ResourceType: '',
    StorageConfig: {
      AssociationId: '',
      StorageType: '',
      S3Config: '',
      KinesisVideoStreamConfig: '',
      KinesisStreamConfig: '',
      KinesisFirehoseConfig: ''
    }
  }
};

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

const url = '{{baseUrl}}/instance/:InstanceId/storage-config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ResourceType":"","StorageConfig":{"AssociationId":"","StorageType":"","S3Config":"","KinesisVideoStreamConfig":"","KinesisStreamConfig":"","KinesisFirehoseConfig":""}}'
};

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}}/instance/:InstanceId/storage-config',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceType": "",\n  "StorageConfig": {\n    "AssociationId": "",\n    "StorageType": "",\n    "S3Config": "",\n    "KinesisVideoStreamConfig": "",\n    "KinesisStreamConfig": "",\n    "KinesisFirehoseConfig": ""\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  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/storage-config")
  .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/instance/:InstanceId/storage-config',
  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({
  ResourceType: '',
  StorageConfig: {
    AssociationId: '',
    StorageType: '',
    S3Config: '',
    KinesisVideoStreamConfig: '',
    KinesisStreamConfig: '',
    KinesisFirehoseConfig: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/storage-config',
  headers: {'content-type': 'application/json'},
  body: {
    ResourceType: '',
    StorageConfig: {
      AssociationId: '',
      StorageType: '',
      S3Config: '',
      KinesisVideoStreamConfig: '',
      KinesisStreamConfig: '',
      KinesisFirehoseConfig: ''
    }
  },
  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}}/instance/:InstanceId/storage-config');

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

req.type('json');
req.send({
  ResourceType: '',
  StorageConfig: {
    AssociationId: '',
    StorageType: '',
    S3Config: '',
    KinesisVideoStreamConfig: '',
    KinesisStreamConfig: '',
    KinesisFirehoseConfig: ''
  }
});

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}}/instance/:InstanceId/storage-config',
  headers: {'content-type': 'application/json'},
  data: {
    ResourceType: '',
    StorageConfig: {
      AssociationId: '',
      StorageType: '',
      S3Config: '',
      KinesisVideoStreamConfig: '',
      KinesisStreamConfig: '',
      KinesisFirehoseConfig: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/storage-config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ResourceType":"","StorageConfig":{"AssociationId":"","StorageType":"","S3Config":"","KinesisVideoStreamConfig":"","KinesisStreamConfig":"","KinesisFirehoseConfig":""}}'
};

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 = @{ @"ResourceType": @"",
                              @"StorageConfig": @{ @"AssociationId": @"", @"StorageType": @"", @"S3Config": @"", @"KinesisVideoStreamConfig": @"", @"KinesisStreamConfig": @"", @"KinesisFirehoseConfig": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/instance/:InstanceId/storage-config"]
                                                       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}}/instance/:InstanceId/storage-config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/instance/:InstanceId/storage-config",
  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([
    'ResourceType' => '',
    'StorageConfig' => [
        'AssociationId' => '',
        'StorageType' => '',
        'S3Config' => '',
        'KinesisVideoStreamConfig' => '',
        'KinesisStreamConfig' => '',
        'KinesisFirehoseConfig' => ''
    ]
  ]),
  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}}/instance/:InstanceId/storage-config', [
  'body' => '{
  "ResourceType": "",
  "StorageConfig": {
    "AssociationId": "",
    "StorageType": "",
    "S3Config": "",
    "KinesisVideoStreamConfig": "",
    "KinesisStreamConfig": "",
    "KinesisFirehoseConfig": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/storage-config');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceType' => '',
  'StorageConfig' => [
    'AssociationId' => '',
    'StorageType' => '',
    'S3Config' => '',
    'KinesisVideoStreamConfig' => '',
    'KinesisStreamConfig' => '',
    'KinesisFirehoseConfig' => ''
  ]
]));

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

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

append(json_encode([
  'ResourceType' => '',
  'StorageConfig' => [
    'AssociationId' => '',
    'StorageType' => '',
    'S3Config' => '',
    'KinesisVideoStreamConfig' => '',
    'KinesisStreamConfig' => '',
    'KinesisFirehoseConfig' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/instance/:InstanceId/storage-config');
$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}}/instance/:InstanceId/storage-config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceType": "",
  "StorageConfig": {
    "AssociationId": "",
    "StorageType": "",
    "S3Config": "",
    "KinesisVideoStreamConfig": "",
    "KinesisStreamConfig": "",
    "KinesisFirehoseConfig": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/storage-config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceType": "",
  "StorageConfig": {
    "AssociationId": "",
    "StorageType": "",
    "S3Config": "",
    "KinesisVideoStreamConfig": "",
    "KinesisStreamConfig": "",
    "KinesisFirehoseConfig": ""
  }
}'

import http.client

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

payload = "{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}"

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

conn.request("PUT", "/baseUrl/instance/:InstanceId/storage-config", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/storage-config"

payload = {
    "ResourceType": "",
    "StorageConfig": {
        "AssociationId": "",
        "StorageType": "",
        "S3Config": "",
        "KinesisVideoStreamConfig": "",
        "KinesisStreamConfig": "",
        "KinesisFirehoseConfig": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/storage-config"

payload <- "{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId/storage-config")

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  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/instance/:InstanceId/storage-config') do |req|
  req.body = "{\n  \"ResourceType\": \"\",\n  \"StorageConfig\": {\n    \"AssociationId\": \"\",\n    \"StorageType\": \"\",\n    \"S3Config\": \"\",\n    \"KinesisVideoStreamConfig\": \"\",\n    \"KinesisStreamConfig\": \"\",\n    \"KinesisFirehoseConfig\": \"\"\n  }\n}"
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/instance/:InstanceId/storage-config";

    let payload = json!({
        "ResourceType": "",
        "StorageConfig": json!({
            "AssociationId": "",
            "StorageType": "",
            "S3Config": "",
            "KinesisVideoStreamConfig": "",
            "KinesisStreamConfig": "",
            "KinesisFirehoseConfig": ""
        })
    });

    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 '{
  "ResourceType": "",
  "StorageConfig": {
    "AssociationId": "",
    "StorageType": "",
    "S3Config": "",
    "KinesisVideoStreamConfig": "",
    "KinesisStreamConfig": "",
    "KinesisFirehoseConfig": ""
  }
}' |  \
  http PUT {{baseUrl}}/instance/:InstanceId/storage-config \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceType": "",\n  "StorageConfig": {\n    "AssociationId": "",\n    "StorageType": "",\n    "S3Config": "",\n    "KinesisVideoStreamConfig": "",\n    "KinesisStreamConfig": "",\n    "KinesisFirehoseConfig": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/storage-config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ResourceType": "",
  "StorageConfig": [
    "AssociationId": "",
    "StorageType": "",
    "S3Config": "",
    "KinesisVideoStreamConfig": "",
    "KinesisStreamConfig": "",
    "KinesisFirehoseConfig": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/storage-config")! 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}}/instance/:InstanceId/lambda-function");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance/:InstanceId/lambda-function" {:content-type :json
                                                                                :form-params {:FunctionArn ""}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/lambda-function"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"FunctionArn\": \"\"\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}}/instance/:InstanceId/lambda-function"),
    Content = new StringContent("{\n  \"FunctionArn\": \"\"\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}}/instance/:InstanceId/lambda-function");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FunctionArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/lambda-function"

	payload := strings.NewReader("{\n  \"FunctionArn\": \"\"\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/instance/:InstanceId/lambda-function HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "FunctionArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance/:InstanceId/lambda-function")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FunctionArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/lambda-function"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"FunctionArn\": \"\"\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  \"FunctionArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/lambda-function")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance/:InstanceId/lambda-function")
  .header("content-type", "application/json")
  .body("{\n  \"FunctionArn\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/instance/:InstanceId/lambda-function');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/lambda-function',
  headers: {'content-type': 'application/json'},
  data: {FunctionArn: ''}
};

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

const url = '{{baseUrl}}/instance/:InstanceId/lambda-function';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"FunctionArn":""}'
};

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}}/instance/:InstanceId/lambda-function',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FunctionArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FunctionArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/lambda-function")
  .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/instance/:InstanceId/lambda-function',
  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({FunctionArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/lambda-function',
  headers: {'content-type': 'application/json'},
  body: {FunctionArn: ''},
  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}}/instance/:InstanceId/lambda-function');

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

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

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}}/instance/:InstanceId/lambda-function',
  headers: {'content-type': 'application/json'},
  data: {FunctionArn: ''}
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/lambda-function';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"FunctionArn":""}'
};

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

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

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

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

 "{{baseUrl}}/instance/:InstanceId/lambda-function",
  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([
    'FunctionArn' => ''
  ]),
  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}}/instance/:InstanceId/lambda-function', [
  'body' => '{
  "FunctionArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/lambda-function');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'FunctionArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/instance/:InstanceId/lambda-function');
$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}}/instance/:InstanceId/lambda-function' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "FunctionArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/lambda-function' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "FunctionArn": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/instance/:InstanceId/lambda-function", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/lambda-function"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/lambda-function"

payload <- "{\n  \"FunctionArn\": \"\"\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}}/instance/:InstanceId/lambda-function")

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  \"FunctionArn\": \"\"\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/instance/:InstanceId/lambda-function') do |req|
  req.body = "{\n  \"FunctionArn\": \"\"\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}}/instance/:InstanceId/lambda-function";

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

    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 '{
  "FunctionArn": ""
}' |  \
  http PUT {{baseUrl}}/instance/:InstanceId/lambda-function \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "FunctionArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/lambda-function

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/lambda-function")! 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}}/instance/:InstanceId/lex-bot");

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  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance/:InstanceId/lex-bot" {:content-type :json
                                                                        :form-params {:LexBot {:Name ""
                                                                                               :LexRegion ""}}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/lex-bot"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/instance/:InstanceId/lex-bot"),
    Content = new StringContent("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\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}}/instance/:InstanceId/lex-bot");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/lex-bot"

	payload := strings.NewReader("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\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/instance/:InstanceId/lex-bot HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance/:InstanceId/lex-bot")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/lex-bot"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\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  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/lex-bot")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance/:InstanceId/lex-bot")
  .header("content-type", "application/json")
  .body("{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  LexBot: {
    Name: '',
    LexRegion: ''
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/instance/:InstanceId/lex-bot');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/lex-bot',
  headers: {'content-type': 'application/json'},
  data: {LexBot: {Name: '', LexRegion: ''}}
};

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

const url = '{{baseUrl}}/instance/:InstanceId/lex-bot';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LexBot":{"Name":"","LexRegion":""}}'
};

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}}/instance/:InstanceId/lex-bot',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LexBot": {\n    "Name": "",\n    "LexRegion": ""\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  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/lex-bot")
  .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/instance/:InstanceId/lex-bot',
  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({LexBot: {Name: '', LexRegion: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/lex-bot',
  headers: {'content-type': 'application/json'},
  body: {LexBot: {Name: '', LexRegion: ''}},
  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}}/instance/:InstanceId/lex-bot');

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

req.type('json');
req.send({
  LexBot: {
    Name: '',
    LexRegion: ''
  }
});

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}}/instance/:InstanceId/lex-bot',
  headers: {'content-type': 'application/json'},
  data: {LexBot: {Name: '', LexRegion: ''}}
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/lex-bot';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LexBot":{"Name":"","LexRegion":""}}'
};

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 = @{ @"LexBot": @{ @"Name": @"", @"LexRegion": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/instance/:InstanceId/lex-bot"]
                                                       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}}/instance/:InstanceId/lex-bot" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/instance/:InstanceId/lex-bot",
  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([
    'LexBot' => [
        'Name' => '',
        'LexRegion' => ''
    ]
  ]),
  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}}/instance/:InstanceId/lex-bot', [
  'body' => '{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/lex-bot');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LexBot' => [
    'Name' => '',
    'LexRegion' => ''
  ]
]));

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

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

append(json_encode([
  'LexBot' => [
    'Name' => '',
    'LexRegion' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/instance/:InstanceId/lex-bot');
$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}}/instance/:InstanceId/lex-bot' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/lex-bot' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  }
}'

import http.client

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

payload = "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}"

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

conn.request("PUT", "/baseUrl/instance/:InstanceId/lex-bot", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/lex-bot"

payload = { "LexBot": {
        "Name": "",
        "LexRegion": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/lex-bot"

payload <- "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId/lex-bot")

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  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/instance/:InstanceId/lex-bot') do |req|
  req.body = "{\n  \"LexBot\": {\n    \"Name\": \"\",\n    \"LexRegion\": \"\"\n  }\n}"
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/instance/:InstanceId/lex-bot";

    let payload = json!({"LexBot": json!({
            "Name": "",
            "LexRegion": ""
        })});

    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 '{
  "LexBot": {
    "Name": "",
    "LexRegion": ""
  }
}' |  \
  http PUT {{baseUrl}}/instance/:InstanceId/lex-bot \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "LexBot": {\n    "Name": "",\n    "LexRegion": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/lex-bot

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["LexBot": [
    "Name": "",
    "LexRegion": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/lex-bot")! 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}}/phone-number/:PhoneNumberId/contact-flow");

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  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow" {:content-type :json
                                                                                    :form-params {:InstanceId ""
                                                                                                  :ContactFlowId ""}})

require "http/client"

url = "{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\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}}/phone-number/:PhoneNumberId/contact-flow"),
    Content = new StringContent("{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\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}}/phone-number/:PhoneNumberId/contact-flow");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow"

	payload := strings.NewReader("{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\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/phone-number/:PhoneNumberId/contact-flow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "InstanceId": "",
  "ContactFlowId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\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  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow")
  .header("content-type", "application/json")
  .body("{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InstanceId: '',
  ContactFlowId: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow',
  headers: {'content-type': 'application/json'},
  data: {InstanceId: '', ContactFlowId: ''}
};

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

const url = '{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"InstanceId":"","ContactFlowId":""}'
};

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}}/phone-number/:PhoneNumberId/contact-flow',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InstanceId": "",\n  "ContactFlowId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow")
  .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/phone-number/:PhoneNumberId/contact-flow',
  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({InstanceId: '', ContactFlowId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow',
  headers: {'content-type': 'application/json'},
  body: {InstanceId: '', ContactFlowId: ''},
  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}}/phone-number/:PhoneNumberId/contact-flow');

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

req.type('json');
req.send({
  InstanceId: '',
  ContactFlowId: ''
});

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}}/phone-number/:PhoneNumberId/contact-flow',
  headers: {'content-type': 'application/json'},
  data: {InstanceId: '', ContactFlowId: ''}
};

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

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

const url = '{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"InstanceId":"","ContactFlowId":""}'
};

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 = @{ @"InstanceId": @"",
                              @"ContactFlowId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow"]
                                                       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}}/phone-number/:PhoneNumberId/contact-flow" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\n}" in

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

 "{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow",
  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([
    'InstanceId' => '',
    'ContactFlowId' => ''
  ]),
  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}}/phone-number/:PhoneNumberId/contact-flow', [
  'body' => '{
  "InstanceId": "",
  "ContactFlowId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'InstanceId' => '',
  'ContactFlowId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow');
$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}}/phone-number/:PhoneNumberId/contact-flow' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "ContactFlowId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "ContactFlowId": ""
}'

import http.client

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

payload = "{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/phone-number/:PhoneNumberId/contact-flow", payload, headers)

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

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

import requests

url = "{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow"

payload = {
    "InstanceId": "",
    "ContactFlowId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow"

payload <- "{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\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}}/phone-number/:PhoneNumberId/contact-flow")

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  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\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/phone-number/:PhoneNumberId/contact-flow') do |req|
  req.body = "{\n  \"InstanceId\": \"\",\n  \"ContactFlowId\": \"\"\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}}/phone-number/:PhoneNumberId/contact-flow";

    let payload = json!({
        "InstanceId": "",
        "ContactFlowId": ""
    });

    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 '{
  "InstanceId": "",
  "ContactFlowId": ""
}' |  \
  http PUT {{baseUrl}}/phone-number/:PhoneNumberId/contact-flow \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "InstanceId": "",\n  "ContactFlowId": ""\n}' \
  --output-document \
  - {{baseUrl}}/phone-number/:PhoneNumberId/contact-flow

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/phone-number/:PhoneNumberId/contact-flow")! 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}}/queues/:InstanceId/:QueueId/associate-quick-connects");

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  \"QuickConnectIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects" {:content-type :json
                                                                                                 :form-params {:QuickConnectIds []}})

require "http/client"

url = "{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"QuickConnectIds\": []\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}}/queues/:InstanceId/:QueueId/associate-quick-connects"),
    Content = new StringContent("{\n  \"QuickConnectIds\": []\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}}/queues/:InstanceId/:QueueId/associate-quick-connects");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QuickConnectIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects"

	payload := strings.NewReader("{\n  \"QuickConnectIds\": []\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/queues/:InstanceId/:QueueId/associate-quick-connects HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 27

{
  "QuickConnectIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QuickConnectIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QuickConnectIds\": []\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  \"QuickConnectIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects")
  .header("content-type", "application/json")
  .body("{\n  \"QuickConnectIds\": []\n}")
  .asString();

const data = JSON.stringify({
  QuickConnectIds: []
});

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

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

xhr.open('POST', '{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects',
  headers: {'content-type': 'application/json'},
  data: {QuickConnectIds: []}
};

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

const url = '{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"QuickConnectIds":[]}'
};

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}}/queues/:InstanceId/:QueueId/associate-quick-connects',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QuickConnectIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QuickConnectIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects")
  .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/queues/:InstanceId/:QueueId/associate-quick-connects',
  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({QuickConnectIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects',
  headers: {'content-type': 'application/json'},
  body: {QuickConnectIds: []},
  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}}/queues/:InstanceId/:QueueId/associate-quick-connects');

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

req.type('json');
req.send({
  QuickConnectIds: []
});

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}}/queues/:InstanceId/:QueueId/associate-quick-connects',
  headers: {'content-type': 'application/json'},
  data: {QuickConnectIds: []}
};

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

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

const url = '{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"QuickConnectIds":[]}'
};

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 = @{ @"QuickConnectIds": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects"]
                                                       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}}/queues/:InstanceId/:QueueId/associate-quick-connects" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"QuickConnectIds\": []\n}" in

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

 "{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects",
  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([
    'QuickConnectIds' => [
        
    ]
  ]),
  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}}/queues/:InstanceId/:QueueId/associate-quick-connects', [
  'body' => '{
  "QuickConnectIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'QuickConnectIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects');
$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}}/queues/:InstanceId/:QueueId/associate-quick-connects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QuickConnectIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QuickConnectIds": []
}'

import http.client

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

payload = "{\n  \"QuickConnectIds\": []\n}"

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

conn.request("POST", "/baseUrl/queues/:InstanceId/:QueueId/associate-quick-connects", payload, headers)

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

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

import requests

url = "{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects"

payload = { "QuickConnectIds": [] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects"

payload <- "{\n  \"QuickConnectIds\": []\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}}/queues/:InstanceId/:QueueId/associate-quick-connects")

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  \"QuickConnectIds\": []\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/queues/:InstanceId/:QueueId/associate-quick-connects') do |req|
  req.body = "{\n  \"QuickConnectIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects";

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

    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 '{
  "QuickConnectIds": []
}' |  \
  http POST {{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "QuickConnectIds": []\n}' \
  --output-document \
  - {{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/queues/:InstanceId/:QueueId/associate-quick-connects")! 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}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues");

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  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues" {:content-type :json
                                                                                                            :form-params {:QueueConfigs [{:QueueReference ""
                                                                                                                                          :Priority ""
                                                                                                                                          :Delay ""}]}})

require "http/client"

url = "{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues"),
    Content = new StringContent("{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues"

	payload := strings.NewReader("{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\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/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues")
  .header("content-type", "application/json")
  .body("{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  QueueConfigs: [
    {
      QueueReference: '',
      Priority: '',
      Delay: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues',
  headers: {'content-type': 'application/json'},
  data: {QueueConfigs: [{QueueReference: '', Priority: '', Delay: ''}]}
};

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

const url = '{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"QueueConfigs":[{"QueueReference":"","Priority":"","Delay":""}]}'
};

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}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QueueConfigs": [\n    {\n      "QueueReference": "",\n      "Priority": "",\n      "Delay": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues")
  .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/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues',
  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({QueueConfigs: [{QueueReference: '', Priority: '', Delay: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues',
  headers: {'content-type': 'application/json'},
  body: {QueueConfigs: [{QueueReference: '', Priority: '', Delay: ''}]},
  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}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues');

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

req.type('json');
req.send({
  QueueConfigs: [
    {
      QueueReference: '',
      Priority: '',
      Delay: ''
    }
  ]
});

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}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues',
  headers: {'content-type': 'application/json'},
  data: {QueueConfigs: [{QueueReference: '', Priority: '', Delay: ''}]}
};

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

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

const url = '{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"QueueConfigs":[{"QueueReference":"","Priority":"","Delay":""}]}'
};

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 = @{ @"QueueConfigs": @[ @{ @"QueueReference": @"", @"Priority": @"", @"Delay": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues"]
                                                       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}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues",
  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([
    'QueueConfigs' => [
        [
                'QueueReference' => '',
                'Priority' => '',
                'Delay' => ''
        ]
    ]
  ]),
  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}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues', [
  'body' => '{
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QueueConfigs' => [
    [
        'QueueReference' => '',
        'Priority' => '',
        'Delay' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'QueueConfigs' => [
    [
        'QueueReference' => '',
        'Priority' => '',
        'Delay' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues');
$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}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues", payload, headers)

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

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

import requests

url = "{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues"

payload = { "QueueConfigs": [
        {
            "QueueReference": "",
            "Priority": "",
            "Delay": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues"

payload <- "{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\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}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues")

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  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues') do |req|
  req.body = "{\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues";

    let payload = json!({"QueueConfigs": (
            json!({
                "QueueReference": "",
                "Priority": "",
                "Delay": ""
            })
        )});

    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 '{
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "QueueConfigs": [\n    {\n      "QueueReference": "",\n      "Priority": "",\n      "Delay": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["QueueConfigs": [
    [
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/routing-profiles/:InstanceId/:RoutingProfileId/associate-queues")! 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}}/instance/:InstanceId/security-key");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance/:InstanceId/security-key" {:content-type :json
                                                                             :form-params {:Key ""}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/security-key"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Key\": \"\"\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}}/instance/:InstanceId/security-key"),
    Content = new StringContent("{\n  \"Key\": \"\"\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}}/instance/:InstanceId/security-key");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Key\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/security-key"

	payload := strings.NewReader("{\n  \"Key\": \"\"\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/instance/:InstanceId/security-key HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "Key": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance/:InstanceId/security-key")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Key\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/security-key"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Key\": \"\"\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  \"Key\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/security-key")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance/:InstanceId/security-key")
  .header("content-type", "application/json")
  .body("{\n  \"Key\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/instance/:InstanceId/security-key');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/security-key',
  headers: {'content-type': 'application/json'},
  data: {Key: ''}
};

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

const url = '{{baseUrl}}/instance/:InstanceId/security-key';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Key":""}'
};

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}}/instance/:InstanceId/security-key',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Key": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Key\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/security-key")
  .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/instance/:InstanceId/security-key',
  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({Key: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/security-key',
  headers: {'content-type': 'application/json'},
  body: {Key: ''},
  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}}/instance/:InstanceId/security-key');

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

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

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}}/instance/:InstanceId/security-key',
  headers: {'content-type': 'application/json'},
  data: {Key: ''}
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/security-key';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Key":""}'
};

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

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

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

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

 "{{baseUrl}}/instance/:InstanceId/security-key",
  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([
    'Key' => ''
  ]),
  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}}/instance/:InstanceId/security-key', [
  'body' => '{
  "Key": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/security-key');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'Key' => ''
]));
$request->setRequestUrl('{{baseUrl}}/instance/:InstanceId/security-key');
$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}}/instance/:InstanceId/security-key' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Key": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/security-key' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Key": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/instance/:InstanceId/security-key", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/security-key"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/security-key"

payload <- "{\n  \"Key\": \"\"\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}}/instance/:InstanceId/security-key")

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  \"Key\": \"\"\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/instance/:InstanceId/security-key') do |req|
  req.body = "{\n  \"Key\": \"\"\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}}/instance/:InstanceId/security-key";

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

    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 '{
  "Key": ""
}' |  \
  http PUT {{baseUrl}}/instance/:InstanceId/security-key \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Key": ""\n}' \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/security-key

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/security-key")! 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}}/phone-number/claim");

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  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/phone-number/claim" {:content-type :json
                                                               :form-params {:TargetArn ""
                                                                             :PhoneNumber ""
                                                                             :PhoneNumberDescription ""
                                                                             :Tags {}
                                                                             :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/phone-number/claim"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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}}/phone-number/claim"),
    Content = new StringContent("{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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}}/phone-number/claim");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/phone-number/claim"

	payload := strings.NewReader("{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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/phone-number/claim HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 109

{
  "TargetArn": "",
  "PhoneNumber": "",
  "PhoneNumberDescription": "",
  "Tags": {},
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/phone-number/claim")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/phone-number/claim"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/phone-number/claim")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/phone-number/claim")
  .header("content-type", "application/json")
  .body("{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TargetArn: '',
  PhoneNumber: '',
  PhoneNumberDescription: '',
  Tags: {},
  ClientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/phone-number/claim',
  headers: {'content-type': 'application/json'},
  data: {
    TargetArn: '',
    PhoneNumber: '',
    PhoneNumberDescription: '',
    Tags: {},
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/phone-number/claim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TargetArn":"","PhoneNumber":"","PhoneNumberDescription":"","Tags":{},"ClientToken":""}'
};

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}}/phone-number/claim',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TargetArn": "",\n  "PhoneNumber": "",\n  "PhoneNumberDescription": "",\n  "Tags": {},\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/phone-number/claim")
  .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/phone-number/claim',
  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({
  TargetArn: '',
  PhoneNumber: '',
  PhoneNumberDescription: '',
  Tags: {},
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/phone-number/claim',
  headers: {'content-type': 'application/json'},
  body: {
    TargetArn: '',
    PhoneNumber: '',
    PhoneNumberDescription: '',
    Tags: {},
    ClientToken: ''
  },
  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}}/phone-number/claim');

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

req.type('json');
req.send({
  TargetArn: '',
  PhoneNumber: '',
  PhoneNumberDescription: '',
  Tags: {},
  ClientToken: ''
});

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}}/phone-number/claim',
  headers: {'content-type': 'application/json'},
  data: {
    TargetArn: '',
    PhoneNumber: '',
    PhoneNumberDescription: '',
    Tags: {},
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/phone-number/claim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TargetArn":"","PhoneNumber":"","PhoneNumberDescription":"","Tags":{},"ClientToken":""}'
};

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 = @{ @"TargetArn": @"",
                              @"PhoneNumber": @"",
                              @"PhoneNumberDescription": @"",
                              @"Tags": @{  },
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/phone-number/claim"]
                                                       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}}/phone-number/claim" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/phone-number/claim",
  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([
    'TargetArn' => '',
    'PhoneNumber' => '',
    'PhoneNumberDescription' => '',
    'Tags' => [
        
    ],
    'ClientToken' => ''
  ]),
  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}}/phone-number/claim', [
  'body' => '{
  "TargetArn": "",
  "PhoneNumber": "",
  "PhoneNumberDescription": "",
  "Tags": {},
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/phone-number/claim');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TargetArn' => '',
  'PhoneNumber' => '',
  'PhoneNumberDescription' => '',
  'Tags' => [
    
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'TargetArn' => '',
  'PhoneNumber' => '',
  'PhoneNumberDescription' => '',
  'Tags' => [
    
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/phone-number/claim');
$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}}/phone-number/claim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetArn": "",
  "PhoneNumber": "",
  "PhoneNumberDescription": "",
  "Tags": {},
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/phone-number/claim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetArn": "",
  "PhoneNumber": "",
  "PhoneNumberDescription": "",
  "Tags": {},
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/phone-number/claim", payload, headers)

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

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

import requests

url = "{{baseUrl}}/phone-number/claim"

payload = {
    "TargetArn": "",
    "PhoneNumber": "",
    "PhoneNumberDescription": "",
    "Tags": {},
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/phone-number/claim"

payload <- "{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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}}/phone-number/claim")

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  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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/phone-number/claim') do |req|
  req.body = "{\n  \"TargetArn\": \"\",\n  \"PhoneNumber\": \"\",\n  \"PhoneNumberDescription\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "TargetArn": "",
        "PhoneNumber": "",
        "PhoneNumberDescription": "",
        "Tags": json!({}),
        "ClientToken": ""
    });

    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 '{
  "TargetArn": "",
  "PhoneNumber": "",
  "PhoneNumberDescription": "",
  "Tags": {},
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/phone-number/claim \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "TargetArn": "",\n  "PhoneNumber": "",\n  "PhoneNumberDescription": "",\n  "Tags": {},\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/phone-number/claim

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "TargetArn": "",
  "PhoneNumber": "",
  "PhoneNumberDescription": "",
  "Tags": [],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/phone-number/claim")! 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}}/agent-status/:InstanceId");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/agent-status/:InstanceId" {:content-type :json
                                                                    :form-params {:Name ""
                                                                                  :Description ""
                                                                                  :State ""
                                                                                  :DisplayOrder 0
                                                                                  :Tags {}}})

require "http/client"

url = "{{baseUrl}}/agent-status/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\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}}/agent-status/:InstanceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\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}}/agent-status/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/agent-status/:InstanceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\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/agent-status/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "Name": "",
  "Description": "",
  "State": "",
  "DisplayOrder": 0,
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/agent-status/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/agent-status/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/agent-status/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/agent-status/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  State: '',
  DisplayOrder: 0,
  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}}/agent-status/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/agent-status/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', State: '', DisplayOrder: 0, Tags: {}}
};

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

const url = '{{baseUrl}}/agent-status/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","State":"","DisplayOrder":0,"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}}/agent-status/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "State": "",\n  "DisplayOrder": 0,\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/agent-status/:InstanceId")
  .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/agent-status/:InstanceId',
  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({Name: '', Description: '', State: '', DisplayOrder: 0, Tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/agent-status/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {Name: '', Description: '', State: '', DisplayOrder: 0, 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}}/agent-status/:InstanceId');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  State: '',
  DisplayOrder: 0,
  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}}/agent-status/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', State: '', DisplayOrder: 0, Tags: {}}
};

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

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

const url = '{{baseUrl}}/agent-status/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","State":"","DisplayOrder":0,"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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"State": @"",
                              @"DisplayOrder": @0,
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/agent-status/:InstanceId"]
                                                       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}}/agent-status/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/agent-status/:InstanceId",
  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([
    'Name' => '',
    'Description' => '',
    'State' => '',
    'DisplayOrder' => 0,
    '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}}/agent-status/:InstanceId', [
  'body' => '{
  "Name": "",
  "Description": "",
  "State": "",
  "DisplayOrder": 0,
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/agent-status/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'State' => '',
  'DisplayOrder' => 0,
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'State' => '',
  'DisplayOrder' => 0,
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/agent-status/:InstanceId');
$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}}/agent-status/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "State": "",
  "DisplayOrder": 0,
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/agent-status/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "State": "",
  "DisplayOrder": 0,
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/agent-status/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/agent-status/:InstanceId"

payload = {
    "Name": "",
    "Description": "",
    "State": "",
    "DisplayOrder": 0,
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/agent-status/:InstanceId"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\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}}/agent-status/:InstanceId")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\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/agent-status/:InstanceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"State\": \"\",\n  \"DisplayOrder\": 0,\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}}/agent-status/:InstanceId";

    let payload = json!({
        "Name": "",
        "Description": "",
        "State": "",
        "DisplayOrder": 0,
        "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 '{
  "Name": "",
  "Description": "",
  "State": "",
  "DisplayOrder": 0,
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/agent-status/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "State": "",\n  "DisplayOrder": 0,\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/agent-status/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "State": "",
  "DisplayOrder": 0,
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/agent-status/:InstanceId")! 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}}/contact-flows/:InstanceId");

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  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/contact-flows/:InstanceId" {:content-type :json
                                                                     :form-params {:Name ""
                                                                                   :Type ""
                                                                                   :Description ""
                                                                                   :Content ""
                                                                                   :Tags {}}})

require "http/client"

url = "{{baseUrl}}/contact-flows/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\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}}/contact-flows/:InstanceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\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}}/contact-flows/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/contact-flows/:InstanceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\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/contact-flows/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 82

{
  "Name": "",
  "Type": "",
  "Description": "",
  "Content": "",
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/contact-flows/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact-flows/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\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  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contact-flows/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/contact-flows/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Type: '',
  Description: '',
  Content: '',
  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}}/contact-flows/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/contact-flows/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Type: '', Description: '', Content: '', Tags: {}}
};

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

const url = '{{baseUrl}}/contact-flows/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Type":"","Description":"","Content":"","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}}/contact-flows/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Type": "",\n  "Description": "",\n  "Content": "",\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  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contact-flows/:InstanceId")
  .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/contact-flows/:InstanceId',
  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({Name: '', Type: '', Description: '', Content: '', Tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/contact-flows/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {Name: '', Type: '', Description: '', Content: '', 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}}/contact-flows/:InstanceId');

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

req.type('json');
req.send({
  Name: '',
  Type: '',
  Description: '',
  Content: '',
  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}}/contact-flows/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Type: '', Description: '', Content: '', Tags: {}}
};

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

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

const url = '{{baseUrl}}/contact-flows/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Type":"","Description":"","Content":"","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 = @{ @"Name": @"",
                              @"Type": @"",
                              @"Description": @"",
                              @"Content": @"",
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contact-flows/:InstanceId"]
                                                       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}}/contact-flows/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/contact-flows/:InstanceId",
  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([
    'Name' => '',
    'Type' => '',
    'Description' => '',
    'Content' => '',
    '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}}/contact-flows/:InstanceId', [
  'body' => '{
  "Name": "",
  "Type": "",
  "Description": "",
  "Content": "",
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contact-flows/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Type' => '',
  'Description' => '',
  'Content' => '',
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Type' => '',
  'Description' => '',
  'Content' => '',
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/contact-flows/:InstanceId');
$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}}/contact-flows/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Type": "",
  "Description": "",
  "Content": "",
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact-flows/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Type": "",
  "Description": "",
  "Content": "",
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/contact-flows/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/contact-flows/:InstanceId"

payload = {
    "Name": "",
    "Type": "",
    "Description": "",
    "Content": "",
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact-flows/:InstanceId"

payload <- "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\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}}/contact-flows/:InstanceId")

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  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\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/contact-flows/:InstanceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\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}}/contact-flows/:InstanceId";

    let payload = json!({
        "Name": "",
        "Type": "",
        "Description": "",
        "Content": "",
        "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 '{
  "Name": "",
  "Type": "",
  "Description": "",
  "Content": "",
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/contact-flows/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Type": "",\n  "Description": "",\n  "Content": "",\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/contact-flows/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Type": "",
  "Description": "",
  "Content": "",
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact-flows/:InstanceId")! 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}}/contact-flow-modules/:InstanceId");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/contact-flow-modules/:InstanceId" {:content-type :json
                                                                            :form-params {:Name ""
                                                                                          :Description ""
                                                                                          :Content ""
                                                                                          :Tags {}
                                                                                          :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/contact-flow-modules/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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}}/contact-flow-modules/:InstanceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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}}/contact-flow-modules/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/contact-flow-modules/:InstanceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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/contact-flow-modules/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 89

{
  "Name": "",
  "Description": "",
  "Content": "",
  "Tags": {},
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/contact-flow-modules/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact-flow-modules/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contact-flow-modules/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/contact-flow-modules/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  Content: '',
  Tags: {},
  ClientToken: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/contact-flow-modules/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/contact-flow-modules/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', Content: '', Tags: {}, ClientToken: ''}
};

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

const url = '{{baseUrl}}/contact-flow-modules/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","Content":"","Tags":{},"ClientToken":""}'
};

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}}/contact-flow-modules/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "Content": "",\n  "Tags": {},\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contact-flow-modules/:InstanceId")
  .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/contact-flow-modules/:InstanceId',
  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({Name: '', Description: '', Content: '', Tags: {}, ClientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/contact-flow-modules/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {Name: '', Description: '', Content: '', Tags: {}, ClientToken: ''},
  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}}/contact-flow-modules/:InstanceId');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  Content: '',
  Tags: {},
  ClientToken: ''
});

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}}/contact-flow-modules/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', Content: '', Tags: {}, ClientToken: ''}
};

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

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

const url = '{{baseUrl}}/contact-flow-modules/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","Content":"","Tags":{},"ClientToken":""}'
};

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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"Content": @"",
                              @"Tags": @{  },
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contact-flow-modules/:InstanceId"]
                                                       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}}/contact-flow-modules/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/contact-flow-modules/:InstanceId",
  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([
    'Name' => '',
    'Description' => '',
    'Content' => '',
    'Tags' => [
        
    ],
    'ClientToken' => ''
  ]),
  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}}/contact-flow-modules/:InstanceId', [
  'body' => '{
  "Name": "",
  "Description": "",
  "Content": "",
  "Tags": {},
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contact-flow-modules/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'Content' => '',
  'Tags' => [
    
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'Content' => '',
  'Tags' => [
    
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/contact-flow-modules/:InstanceId');
$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}}/contact-flow-modules/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "Content": "",
  "Tags": {},
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact-flow-modules/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "Content": "",
  "Tags": {},
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/contact-flow-modules/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/contact-flow-modules/:InstanceId"

payload = {
    "Name": "",
    "Description": "",
    "Content": "",
    "Tags": {},
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact-flow-modules/:InstanceId"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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}}/contact-flow-modules/:InstanceId")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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/contact-flow-modules/:InstanceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {},\n  \"ClientToken\": \"\"\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}}/contact-flow-modules/:InstanceId";

    let payload = json!({
        "Name": "",
        "Description": "",
        "Content": "",
        "Tags": json!({}),
        "ClientToken": ""
    });

    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 '{
  "Name": "",
  "Description": "",
  "Content": "",
  "Tags": {},
  "ClientToken": ""
}' |  \
  http PUT {{baseUrl}}/contact-flow-modules/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "Content": "",\n  "Tags": {},\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/contact-flow-modules/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "Content": "",
  "Tags": [],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact-flow-modules/:InstanceId")! 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}}/hours-of-operations/:InstanceId");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/hours-of-operations/:InstanceId" {:content-type :json
                                                                           :form-params {:Name ""
                                                                                         :Description ""
                                                                                         :TimeZone ""
                                                                                         :Config [{:Day ""
                                                                                                   :StartTime ""
                                                                                                   :EndTime ""}]
                                                                                         :Tags {}}})

require "http/client"

url = "{{baseUrl}}/hours-of-operations/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\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}}/hours-of-operations/:InstanceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\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}}/hours-of-operations/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/hours-of-operations/:InstanceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\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/hours-of-operations/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 160

{
  "Name": "",
  "Description": "",
  "TimeZone": "",
  "Config": [
    {
      "Day": "",
      "StartTime": "",
      "EndTime": ""
    }
  ],
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/hours-of-operations/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/hours-of-operations/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/hours-of-operations/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/hours-of-operations/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  TimeZone: '',
  Config: [
    {
      Day: '',
      StartTime: '',
      EndTime: ''
    }
  ],
  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}}/hours-of-operations/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/hours-of-operations/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    TimeZone: '',
    Config: [{Day: '', StartTime: '', EndTime: ''}],
    Tags: {}
  }
};

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

const url = '{{baseUrl}}/hours-of-operations/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","TimeZone":"","Config":[{"Day":"","StartTime":"","EndTime":""}],"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}}/hours-of-operations/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "TimeZone": "",\n  "Config": [\n    {\n      "Day": "",\n      "StartTime": "",\n      "EndTime": ""\n    }\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/hours-of-operations/:InstanceId")
  .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/hours-of-operations/:InstanceId',
  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({
  Name: '',
  Description: '',
  TimeZone: '',
  Config: [{Day: '', StartTime: '', EndTime: ''}],
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/hours-of-operations/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    TimeZone: '',
    Config: [{Day: '', StartTime: '', EndTime: ''}],
    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}}/hours-of-operations/:InstanceId');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  TimeZone: '',
  Config: [
    {
      Day: '',
      StartTime: '',
      EndTime: ''
    }
  ],
  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}}/hours-of-operations/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    TimeZone: '',
    Config: [{Day: '', StartTime: '', EndTime: ''}],
    Tags: {}
  }
};

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

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

const url = '{{baseUrl}}/hours-of-operations/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","TimeZone":"","Config":[{"Day":"","StartTime":"","EndTime":""}],"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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"TimeZone": @"",
                              @"Config": @[ @{ @"Day": @"", @"StartTime": @"", @"EndTime": @"" } ],
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/hours-of-operations/:InstanceId"]
                                                       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}}/hours-of-operations/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/hours-of-operations/:InstanceId",
  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([
    'Name' => '',
    'Description' => '',
    'TimeZone' => '',
    'Config' => [
        [
                'Day' => '',
                'StartTime' => '',
                'EndTime' => ''
        ]
    ],
    '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}}/hours-of-operations/:InstanceId', [
  'body' => '{
  "Name": "",
  "Description": "",
  "TimeZone": "",
  "Config": [
    {
      "Day": "",
      "StartTime": "",
      "EndTime": ""
    }
  ],
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/hours-of-operations/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'TimeZone' => '',
  'Config' => [
    [
        'Day' => '',
        'StartTime' => '',
        'EndTime' => ''
    ]
  ],
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'TimeZone' => '',
  'Config' => [
    [
        'Day' => '',
        'StartTime' => '',
        'EndTime' => ''
    ]
  ],
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/hours-of-operations/:InstanceId');
$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}}/hours-of-operations/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "TimeZone": "",
  "Config": [
    {
      "Day": "",
      "StartTime": "",
      "EndTime": ""
    }
  ],
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/hours-of-operations/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "TimeZone": "",
  "Config": [
    {
      "Day": "",
      "StartTime": "",
      "EndTime": ""
    }
  ],
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/hours-of-operations/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/hours-of-operations/:InstanceId"

payload = {
    "Name": "",
    "Description": "",
    "TimeZone": "",
    "Config": [
        {
            "Day": "",
            "StartTime": "",
            "EndTime": ""
        }
    ],
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/hours-of-operations/:InstanceId"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\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}}/hours-of-operations/:InstanceId")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\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/hours-of-operations/:InstanceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"TimeZone\": \"\",\n  \"Config\": [\n    {\n      \"Day\": \"\",\n      \"StartTime\": \"\",\n      \"EndTime\": \"\"\n    }\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}}/hours-of-operations/:InstanceId";

    let payload = json!({
        "Name": "",
        "Description": "",
        "TimeZone": "",
        "Config": (
            json!({
                "Day": "",
                "StartTime": "",
                "EndTime": ""
            })
        ),
        "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 '{
  "Name": "",
  "Description": "",
  "TimeZone": "",
  "Config": [
    {
      "Day": "",
      "StartTime": "",
      "EndTime": ""
    }
  ],
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/hours-of-operations/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "TimeZone": "",\n  "Config": [\n    {\n      "Day": "",\n      "StartTime": "",\n      "EndTime": ""\n    }\n  ],\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/hours-of-operations/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "TimeZone": "",
  "Config": [
    [
      "Day": "",
      "StartTime": "",
      "EndTime": ""
    ]
  ],
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/hours-of-operations/:InstanceId")! 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}}/instance");

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  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance" {:content-type :json
                                                    :form-params {:ClientToken ""
                                                                  :IdentityManagementType ""
                                                                  :InstanceAlias ""
                                                                  :DirectoryId ""
                                                                  :InboundCallsEnabled false
                                                                  :OutboundCallsEnabled false}})

require "http/client"

url = "{{baseUrl}}/instance"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/instance"),
    Content = new StringContent("{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/instance");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\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/instance HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 164

{
  "ClientToken": "",
  "IdentityManagementType": "",
  "InstanceAlias": "",
  "DirectoryId": "",
  "InboundCallsEnabled": false,
  "OutboundCallsEnabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance")
  .header("content-type", "application/json")
  .body("{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}")
  .asString();

const data = JSON.stringify({
  ClientToken: '',
  IdentityManagementType: '',
  InstanceAlias: '',
  DirectoryId: '',
  InboundCallsEnabled: false,
  OutboundCallsEnabled: false
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance',
  headers: {'content-type': 'application/json'},
  data: {
    ClientToken: '',
    IdentityManagementType: '',
    InstanceAlias: '',
    DirectoryId: '',
    InboundCallsEnabled: false,
    OutboundCallsEnabled: false
  }
};

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

const url = '{{baseUrl}}/instance';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ClientToken":"","IdentityManagementType":"","InstanceAlias":"","DirectoryId":"","InboundCallsEnabled":false,"OutboundCallsEnabled":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/instance',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientToken": "",\n  "IdentityManagementType": "",\n  "InstanceAlias": "",\n  "DirectoryId": "",\n  "InboundCallsEnabled": false,\n  "OutboundCallsEnabled": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance")
  .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/instance',
  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({
  ClientToken: '',
  IdentityManagementType: '',
  InstanceAlias: '',
  DirectoryId: '',
  InboundCallsEnabled: false,
  OutboundCallsEnabled: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance',
  headers: {'content-type': 'application/json'},
  body: {
    ClientToken: '',
    IdentityManagementType: '',
    InstanceAlias: '',
    DirectoryId: '',
    InboundCallsEnabled: false,
    OutboundCallsEnabled: false
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/instance');

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

req.type('json');
req.send({
  ClientToken: '',
  IdentityManagementType: '',
  InstanceAlias: '',
  DirectoryId: '',
  InboundCallsEnabled: false,
  OutboundCallsEnabled: false
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance',
  headers: {'content-type': 'application/json'},
  data: {
    ClientToken: '',
    IdentityManagementType: '',
    InstanceAlias: '',
    DirectoryId: '',
    InboundCallsEnabled: false,
    OutboundCallsEnabled: false
  }
};

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

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

const url = '{{baseUrl}}/instance';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ClientToken":"","IdentityManagementType":"","InstanceAlias":"","DirectoryId":"","InboundCallsEnabled":false,"OutboundCallsEnabled":false}'
};

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 = @{ @"ClientToken": @"",
                              @"IdentityManagementType": @"",
                              @"InstanceAlias": @"",
                              @"DirectoryId": @"",
                              @"InboundCallsEnabled": @NO,
                              @"OutboundCallsEnabled": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/instance"]
                                                       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}}/instance" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}" in

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

 "{{baseUrl}}/instance",
  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([
    'ClientToken' => '',
    'IdentityManagementType' => '',
    'InstanceAlias' => '',
    'DirectoryId' => '',
    'InboundCallsEnabled' => null,
    'OutboundCallsEnabled' => null
  ]),
  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}}/instance', [
  'body' => '{
  "ClientToken": "",
  "IdentityManagementType": "",
  "InstanceAlias": "",
  "DirectoryId": "",
  "InboundCallsEnabled": false,
  "OutboundCallsEnabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientToken' => '',
  'IdentityManagementType' => '',
  'InstanceAlias' => '',
  'DirectoryId' => '',
  'InboundCallsEnabled' => null,
  'OutboundCallsEnabled' => null
]));

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

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

append(json_encode([
  'ClientToken' => '',
  'IdentityManagementType' => '',
  'InstanceAlias' => '',
  'DirectoryId' => '',
  'InboundCallsEnabled' => null,
  'OutboundCallsEnabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/instance');
$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}}/instance' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "IdentityManagementType": "",
  "InstanceAlias": "",
  "DirectoryId": "",
  "InboundCallsEnabled": false,
  "OutboundCallsEnabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "IdentityManagementType": "",
  "InstanceAlias": "",
  "DirectoryId": "",
  "InboundCallsEnabled": false,
  "OutboundCallsEnabled": false
}'

import http.client

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

payload = "{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}"

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

conn.request("PUT", "/baseUrl/instance", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance"

payload = {
    "ClientToken": "",
    "IdentityManagementType": "",
    "InstanceAlias": "",
    "DirectoryId": "",
    "InboundCallsEnabled": False,
    "OutboundCallsEnabled": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\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/instance') do |req|
  req.body = "{\n  \"ClientToken\": \"\",\n  \"IdentityManagementType\": \"\",\n  \"InstanceAlias\": \"\",\n  \"DirectoryId\": \"\",\n  \"InboundCallsEnabled\": false,\n  \"OutboundCallsEnabled\": false\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "ClientToken": "",
        "IdentityManagementType": "",
        "InstanceAlias": "",
        "DirectoryId": "",
        "InboundCallsEnabled": false,
        "OutboundCallsEnabled": false
    });

    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 '{
  "ClientToken": "",
  "IdentityManagementType": "",
  "InstanceAlias": "",
  "DirectoryId": "",
  "InboundCallsEnabled": false,
  "OutboundCallsEnabled": false
}' |  \
  http PUT {{baseUrl}}/instance \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientToken": "",\n  "IdentityManagementType": "",\n  "InstanceAlias": "",\n  "DirectoryId": "",\n  "InboundCallsEnabled": false,\n  "OutboundCallsEnabled": false\n}' \
  --output-document \
  - {{baseUrl}}/instance

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ClientToken": "",
  "IdentityManagementType": "",
  "InstanceAlias": "",
  "DirectoryId": "",
  "InboundCallsEnabled": false,
  "OutboundCallsEnabled": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance")! 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}}/instance/:InstanceId/integration-associations");

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  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance/:InstanceId/integration-associations" {:content-type :json
                                                                                         :form-params {:IntegrationType ""
                                                                                                       :IntegrationArn ""
                                                                                                       :SourceApplicationUrl ""
                                                                                                       :SourceApplicationName ""
                                                                                                       :SourceType ""
                                                                                                       :Tags {}}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/integration-associations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\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}}/instance/:InstanceId/integration-associations"),
    Content = new StringContent("{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\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}}/instance/:InstanceId/integration-associations");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/integration-associations"

	payload := strings.NewReader("{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\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/instance/:InstanceId/integration-associations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 146

{
  "IntegrationType": "",
  "IntegrationArn": "",
  "SourceApplicationUrl": "",
  "SourceApplicationName": "",
  "SourceType": "",
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance/:InstanceId/integration-associations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/integration-associations"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\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  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/integration-associations")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance/:InstanceId/integration-associations")
  .header("content-type", "application/json")
  .body("{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  IntegrationType: '',
  IntegrationArn: '',
  SourceApplicationUrl: '',
  SourceApplicationName: '',
  SourceType: '',
  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}}/instance/:InstanceId/integration-associations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/integration-associations',
  headers: {'content-type': 'application/json'},
  data: {
    IntegrationType: '',
    IntegrationArn: '',
    SourceApplicationUrl: '',
    SourceApplicationName: '',
    SourceType: '',
    Tags: {}
  }
};

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

const url = '{{baseUrl}}/instance/:InstanceId/integration-associations';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"IntegrationType":"","IntegrationArn":"","SourceApplicationUrl":"","SourceApplicationName":"","SourceType":"","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}}/instance/:InstanceId/integration-associations',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "IntegrationType": "",\n  "IntegrationArn": "",\n  "SourceApplicationUrl": "",\n  "SourceApplicationName": "",\n  "SourceType": "",\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  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/integration-associations")
  .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/instance/:InstanceId/integration-associations',
  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({
  IntegrationType: '',
  IntegrationArn: '',
  SourceApplicationUrl: '',
  SourceApplicationName: '',
  SourceType: '',
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/integration-associations',
  headers: {'content-type': 'application/json'},
  body: {
    IntegrationType: '',
    IntegrationArn: '',
    SourceApplicationUrl: '',
    SourceApplicationName: '',
    SourceType: '',
    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}}/instance/:InstanceId/integration-associations');

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

req.type('json');
req.send({
  IntegrationType: '',
  IntegrationArn: '',
  SourceApplicationUrl: '',
  SourceApplicationName: '',
  SourceType: '',
  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}}/instance/:InstanceId/integration-associations',
  headers: {'content-type': 'application/json'},
  data: {
    IntegrationType: '',
    IntegrationArn: '',
    SourceApplicationUrl: '',
    SourceApplicationName: '',
    SourceType: '',
    Tags: {}
  }
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/integration-associations';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"IntegrationType":"","IntegrationArn":"","SourceApplicationUrl":"","SourceApplicationName":"","SourceType":"","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 = @{ @"IntegrationType": @"",
                              @"IntegrationArn": @"",
                              @"SourceApplicationUrl": @"",
                              @"SourceApplicationName": @"",
                              @"SourceType": @"",
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/instance/:InstanceId/integration-associations"]
                                                       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}}/instance/:InstanceId/integration-associations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/instance/:InstanceId/integration-associations",
  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([
    'IntegrationType' => '',
    'IntegrationArn' => '',
    'SourceApplicationUrl' => '',
    'SourceApplicationName' => '',
    'SourceType' => '',
    '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}}/instance/:InstanceId/integration-associations', [
  'body' => '{
  "IntegrationType": "",
  "IntegrationArn": "",
  "SourceApplicationUrl": "",
  "SourceApplicationName": "",
  "SourceType": "",
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/integration-associations');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'IntegrationType' => '',
  'IntegrationArn' => '',
  'SourceApplicationUrl' => '',
  'SourceApplicationName' => '',
  'SourceType' => '',
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'IntegrationType' => '',
  'IntegrationArn' => '',
  'SourceApplicationUrl' => '',
  'SourceApplicationName' => '',
  'SourceType' => '',
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/instance/:InstanceId/integration-associations');
$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}}/instance/:InstanceId/integration-associations' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "IntegrationType": "",
  "IntegrationArn": "",
  "SourceApplicationUrl": "",
  "SourceApplicationName": "",
  "SourceType": "",
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/integration-associations' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "IntegrationType": "",
  "IntegrationArn": "",
  "SourceApplicationUrl": "",
  "SourceApplicationName": "",
  "SourceType": "",
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/instance/:InstanceId/integration-associations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/integration-associations"

payload = {
    "IntegrationType": "",
    "IntegrationArn": "",
    "SourceApplicationUrl": "",
    "SourceApplicationName": "",
    "SourceType": "",
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/integration-associations"

payload <- "{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\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}}/instance/:InstanceId/integration-associations")

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  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\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/instance/:InstanceId/integration-associations') do |req|
  req.body = "{\n  \"IntegrationType\": \"\",\n  \"IntegrationArn\": \"\",\n  \"SourceApplicationUrl\": \"\",\n  \"SourceApplicationName\": \"\",\n  \"SourceType\": \"\",\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}}/instance/:InstanceId/integration-associations";

    let payload = json!({
        "IntegrationType": "",
        "IntegrationArn": "",
        "SourceApplicationUrl": "",
        "SourceApplicationName": "",
        "SourceType": "",
        "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 '{
  "IntegrationType": "",
  "IntegrationArn": "",
  "SourceApplicationUrl": "",
  "SourceApplicationName": "",
  "SourceType": "",
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/instance/:InstanceId/integration-associations \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "IntegrationType": "",\n  "IntegrationArn": "",\n  "SourceApplicationUrl": "",\n  "SourceApplicationName": "",\n  "SourceType": "",\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/integration-associations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "IntegrationType": "",
  "IntegrationArn": "",
  "SourceApplicationUrl": "",
  "SourceApplicationName": "",
  "SourceType": "",
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/integration-associations")! 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}}/contact/create-participant");

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  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/contact/create-participant" {:content-type :json
                                                                       :form-params {:InstanceId ""
                                                                                     :ContactId ""
                                                                                     :ClientToken ""
                                                                                     :ParticipantDetails {:ParticipantRole ""
                                                                                                          :DisplayName ""}}})

require "http/client"

url = "{{baseUrl}}/contact/create-participant"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\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}}/contact/create-participant"),
    Content = new StringContent("{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\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}}/contact/create-participant");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/contact/create-participant"

	payload := strings.NewReader("{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\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/contact/create-participant HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 142

{
  "InstanceId": "",
  "ContactId": "",
  "ClientToken": "",
  "ParticipantDetails": {
    "ParticipantRole": "",
    "DisplayName": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contact/create-participant")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact/create-participant"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\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  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contact/create-participant")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/contact/create-participant")
  .header("content-type", "application/json")
  .body("{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  InstanceId: '',
  ContactId: '',
  ClientToken: '',
  ParticipantDetails: {
    ParticipantRole: '',
    DisplayName: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contact/create-participant',
  headers: {'content-type': 'application/json'},
  data: {
    InstanceId: '',
    ContactId: '',
    ClientToken: '',
    ParticipantDetails: {ParticipantRole: '', DisplayName: ''}
  }
};

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

const url = '{{baseUrl}}/contact/create-participant';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InstanceId":"","ContactId":"","ClientToken":"","ParticipantDetails":{"ParticipantRole":"","DisplayName":""}}'
};

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}}/contact/create-participant',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InstanceId": "",\n  "ContactId": "",\n  "ClientToken": "",\n  "ParticipantDetails": {\n    "ParticipantRole": "",\n    "DisplayName": ""\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  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contact/create-participant")
  .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/contact/create-participant',
  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({
  InstanceId: '',
  ContactId: '',
  ClientToken: '',
  ParticipantDetails: {ParticipantRole: '', DisplayName: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contact/create-participant',
  headers: {'content-type': 'application/json'},
  body: {
    InstanceId: '',
    ContactId: '',
    ClientToken: '',
    ParticipantDetails: {ParticipantRole: '', DisplayName: ''}
  },
  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}}/contact/create-participant');

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

req.type('json');
req.send({
  InstanceId: '',
  ContactId: '',
  ClientToken: '',
  ParticipantDetails: {
    ParticipantRole: '',
    DisplayName: ''
  }
});

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}}/contact/create-participant',
  headers: {'content-type': 'application/json'},
  data: {
    InstanceId: '',
    ContactId: '',
    ClientToken: '',
    ParticipantDetails: {ParticipantRole: '', DisplayName: ''}
  }
};

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

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

const url = '{{baseUrl}}/contact/create-participant';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InstanceId":"","ContactId":"","ClientToken":"","ParticipantDetails":{"ParticipantRole":"","DisplayName":""}}'
};

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 = @{ @"InstanceId": @"",
                              @"ContactId": @"",
                              @"ClientToken": @"",
                              @"ParticipantDetails": @{ @"ParticipantRole": @"", @"DisplayName": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contact/create-participant"]
                                                       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}}/contact/create-participant" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/contact/create-participant",
  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([
    'InstanceId' => '',
    'ContactId' => '',
    'ClientToken' => '',
    'ParticipantDetails' => [
        'ParticipantRole' => '',
        'DisplayName' => ''
    ]
  ]),
  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}}/contact/create-participant', [
  'body' => '{
  "InstanceId": "",
  "ContactId": "",
  "ClientToken": "",
  "ParticipantDetails": {
    "ParticipantRole": "",
    "DisplayName": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contact/create-participant');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InstanceId' => '',
  'ContactId' => '',
  'ClientToken' => '',
  'ParticipantDetails' => [
    'ParticipantRole' => '',
    'DisplayName' => ''
  ]
]));

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

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

append(json_encode([
  'InstanceId' => '',
  'ContactId' => '',
  'ClientToken' => '',
  'ParticipantDetails' => [
    'ParticipantRole' => '',
    'DisplayName' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/contact/create-participant');
$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}}/contact/create-participant' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "ContactId": "",
  "ClientToken": "",
  "ParticipantDetails": {
    "ParticipantRole": "",
    "DisplayName": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact/create-participant' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "ContactId": "",
  "ClientToken": "",
  "ParticipantDetails": {
    "ParticipantRole": "",
    "DisplayName": ""
  }
}'

import http.client

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

payload = "{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/contact/create-participant", payload, headers)

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

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

import requests

url = "{{baseUrl}}/contact/create-participant"

payload = {
    "InstanceId": "",
    "ContactId": "",
    "ClientToken": "",
    "ParticipantDetails": {
        "ParticipantRole": "",
        "DisplayName": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact/create-participant"

payload <- "{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\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}}/contact/create-participant")

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  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\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/contact/create-participant') do |req|
  req.body = "{\n  \"InstanceId\": \"\",\n  \"ContactId\": \"\",\n  \"ClientToken\": \"\",\n  \"ParticipantDetails\": {\n    \"ParticipantRole\": \"\",\n    \"DisplayName\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InstanceId": "",
        "ContactId": "",
        "ClientToken": "",
        "ParticipantDetails": json!({
            "ParticipantRole": "",
            "DisplayName": ""
        })
    });

    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 '{
  "InstanceId": "",
  "ContactId": "",
  "ClientToken": "",
  "ParticipantDetails": {
    "ParticipantRole": "",
    "DisplayName": ""
  }
}' |  \
  http POST {{baseUrl}}/contact/create-participant \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InstanceId": "",\n  "ContactId": "",\n  "ClientToken": "",\n  "ParticipantDetails": {\n    "ParticipantRole": "",\n    "DisplayName": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/contact/create-participant

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InstanceId": "",
  "ContactId": "",
  "ClientToken": "",
  "ParticipantDetails": [
    "ParticipantRole": "",
    "DisplayName": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact/create-participant")! 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}}/queues/:InstanceId");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/queues/:InstanceId" {:content-type :json
                                                              :form-params {:Name ""
                                                                            :Description ""
                                                                            :OutboundCallerConfig {:OutboundCallerIdName ""
                                                                                                   :OutboundCallerIdNumberId ""
                                                                                                   :OutboundFlowId ""}
                                                                            :HoursOfOperationId ""
                                                                            :MaxContacts 0
                                                                            :QuickConnectIds []
                                                                            :Tags {}}})

require "http/client"

url = "{{baseUrl}}/queues/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\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}}/queues/:InstanceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\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}}/queues/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/queues/:InstanceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\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/queues/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 250

{
  "Name": "",
  "Description": "",
  "OutboundCallerConfig": {
    "OutboundCallerIdName": "",
    "OutboundCallerIdNumberId": "",
    "OutboundFlowId": ""
  },
  "HoursOfOperationId": "",
  "MaxContacts": 0,
  "QuickConnectIds": [],
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/queues/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/queues/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/queues/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/queues/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  OutboundCallerConfig: {
    OutboundCallerIdName: '',
    OutboundCallerIdNumberId: '',
    OutboundFlowId: ''
  },
  HoursOfOperationId: '',
  MaxContacts: 0,
  QuickConnectIds: [],
  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}}/queues/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/queues/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    OutboundCallerConfig: {OutboundCallerIdName: '', OutboundCallerIdNumberId: '', OutboundFlowId: ''},
    HoursOfOperationId: '',
    MaxContacts: 0,
    QuickConnectIds: [],
    Tags: {}
  }
};

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

const url = '{{baseUrl}}/queues/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","OutboundCallerConfig":{"OutboundCallerIdName":"","OutboundCallerIdNumberId":"","OutboundFlowId":""},"HoursOfOperationId":"","MaxContacts":0,"QuickConnectIds":[],"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}}/queues/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "OutboundCallerConfig": {\n    "OutboundCallerIdName": "",\n    "OutboundCallerIdNumberId": "",\n    "OutboundFlowId": ""\n  },\n  "HoursOfOperationId": "",\n  "MaxContacts": 0,\n  "QuickConnectIds": [],\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/queues/:InstanceId")
  .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/queues/:InstanceId',
  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({
  Name: '',
  Description: '',
  OutboundCallerConfig: {OutboundCallerIdName: '', OutboundCallerIdNumberId: '', OutboundFlowId: ''},
  HoursOfOperationId: '',
  MaxContacts: 0,
  QuickConnectIds: [],
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/queues/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    OutboundCallerConfig: {OutboundCallerIdName: '', OutboundCallerIdNumberId: '', OutboundFlowId: ''},
    HoursOfOperationId: '',
    MaxContacts: 0,
    QuickConnectIds: [],
    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}}/queues/:InstanceId');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  OutboundCallerConfig: {
    OutboundCallerIdName: '',
    OutboundCallerIdNumberId: '',
    OutboundFlowId: ''
  },
  HoursOfOperationId: '',
  MaxContacts: 0,
  QuickConnectIds: [],
  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}}/queues/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    OutboundCallerConfig: {OutboundCallerIdName: '', OutboundCallerIdNumberId: '', OutboundFlowId: ''},
    HoursOfOperationId: '',
    MaxContacts: 0,
    QuickConnectIds: [],
    Tags: {}
  }
};

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

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

const url = '{{baseUrl}}/queues/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","OutboundCallerConfig":{"OutboundCallerIdName":"","OutboundCallerIdNumberId":"","OutboundFlowId":""},"HoursOfOperationId":"","MaxContacts":0,"QuickConnectIds":[],"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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"OutboundCallerConfig": @{ @"OutboundCallerIdName": @"", @"OutboundCallerIdNumberId": @"", @"OutboundFlowId": @"" },
                              @"HoursOfOperationId": @"",
                              @"MaxContacts": @0,
                              @"QuickConnectIds": @[  ],
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/queues/:InstanceId"]
                                                       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}}/queues/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/queues/:InstanceId",
  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([
    'Name' => '',
    'Description' => '',
    'OutboundCallerConfig' => [
        'OutboundCallerIdName' => '',
        'OutboundCallerIdNumberId' => '',
        'OutboundFlowId' => ''
    ],
    'HoursOfOperationId' => '',
    'MaxContacts' => 0,
    'QuickConnectIds' => [
        
    ],
    '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}}/queues/:InstanceId', [
  'body' => '{
  "Name": "",
  "Description": "",
  "OutboundCallerConfig": {
    "OutboundCallerIdName": "",
    "OutboundCallerIdNumberId": "",
    "OutboundFlowId": ""
  },
  "HoursOfOperationId": "",
  "MaxContacts": 0,
  "QuickConnectIds": [],
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/queues/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'OutboundCallerConfig' => [
    'OutboundCallerIdName' => '',
    'OutboundCallerIdNumberId' => '',
    'OutboundFlowId' => ''
  ],
  'HoursOfOperationId' => '',
  'MaxContacts' => 0,
  'QuickConnectIds' => [
    
  ],
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'OutboundCallerConfig' => [
    'OutboundCallerIdName' => '',
    'OutboundCallerIdNumberId' => '',
    'OutboundFlowId' => ''
  ],
  'HoursOfOperationId' => '',
  'MaxContacts' => 0,
  'QuickConnectIds' => [
    
  ],
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/queues/:InstanceId');
$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}}/queues/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "OutboundCallerConfig": {
    "OutboundCallerIdName": "",
    "OutboundCallerIdNumberId": "",
    "OutboundFlowId": ""
  },
  "HoursOfOperationId": "",
  "MaxContacts": 0,
  "QuickConnectIds": [],
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/queues/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "OutboundCallerConfig": {
    "OutboundCallerIdName": "",
    "OutboundCallerIdNumberId": "",
    "OutboundFlowId": ""
  },
  "HoursOfOperationId": "",
  "MaxContacts": 0,
  "QuickConnectIds": [],
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/queues/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/queues/:InstanceId"

payload = {
    "Name": "",
    "Description": "",
    "OutboundCallerConfig": {
        "OutboundCallerIdName": "",
        "OutboundCallerIdNumberId": "",
        "OutboundFlowId": ""
    },
    "HoursOfOperationId": "",
    "MaxContacts": 0,
    "QuickConnectIds": [],
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/queues/:InstanceId"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\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}}/queues/:InstanceId")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\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/queues/:InstanceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"OutboundCallerConfig\": {\n    \"OutboundCallerIdName\": \"\",\n    \"OutboundCallerIdNumberId\": \"\",\n    \"OutboundFlowId\": \"\"\n  },\n  \"HoursOfOperationId\": \"\",\n  \"MaxContacts\": 0,\n  \"QuickConnectIds\": [],\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}}/queues/:InstanceId";

    let payload = json!({
        "Name": "",
        "Description": "",
        "OutboundCallerConfig": json!({
            "OutboundCallerIdName": "",
            "OutboundCallerIdNumberId": "",
            "OutboundFlowId": ""
        }),
        "HoursOfOperationId": "",
        "MaxContacts": 0,
        "QuickConnectIds": (),
        "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 '{
  "Name": "",
  "Description": "",
  "OutboundCallerConfig": {
    "OutboundCallerIdName": "",
    "OutboundCallerIdNumberId": "",
    "OutboundFlowId": ""
  },
  "HoursOfOperationId": "",
  "MaxContacts": 0,
  "QuickConnectIds": [],
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/queues/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "OutboundCallerConfig": {\n    "OutboundCallerIdName": "",\n    "OutboundCallerIdNumberId": "",\n    "OutboundFlowId": ""\n  },\n  "HoursOfOperationId": "",\n  "MaxContacts": 0,\n  "QuickConnectIds": [],\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/queues/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "OutboundCallerConfig": [
    "OutboundCallerIdName": "",
    "OutboundCallerIdNumberId": "",
    "OutboundFlowId": ""
  ],
  "HoursOfOperationId": "",
  "MaxContacts": 0,
  "QuickConnectIds": [],
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/queues/:InstanceId")! 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}}/quick-connects/:InstanceId");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\n  },\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/quick-connects/:InstanceId" {:content-type :json
                                                                      :form-params {:Name ""
                                                                                    :Description ""
                                                                                    :QuickConnectConfig {:QuickConnectType ""
                                                                                                         :UserConfig ""
                                                                                                         :QueueConfig ""
                                                                                                         :PhoneConfig ""}
                                                                                    :Tags {}}})

require "http/client"

url = "{{baseUrl}}/quick-connects/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\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}}/quick-connects/:InstanceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\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}}/quick-connects/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\n  },\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quick-connects/:InstanceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\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/quick-connects/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 177

{
  "Name": "",
  "Description": "",
  "QuickConnectConfig": {
    "QuickConnectType": "",
    "UserConfig": "",
    "QueueConfig": "",
    "PhoneConfig": ""
  },
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/quick-connects/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\n  },\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quick-connects/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\n  },\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/quick-connects/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/quick-connects/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\n  },\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  QuickConnectConfig: {
    QuickConnectType: '',
    UserConfig: '',
    QueueConfig: '',
    PhoneConfig: ''
  },
  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}}/quick-connects/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/quick-connects/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    QuickConnectConfig: {QuickConnectType: '', UserConfig: '', QueueConfig: '', PhoneConfig: ''},
    Tags: {}
  }
};

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

const url = '{{baseUrl}}/quick-connects/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","QuickConnectConfig":{"QuickConnectType":"","UserConfig":"","QueueConfig":"","PhoneConfig":""},"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}}/quick-connects/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "QuickConnectConfig": {\n    "QuickConnectType": "",\n    "UserConfig": "",\n    "QueueConfig": "",\n    "PhoneConfig": ""\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\n  },\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/quick-connects/:InstanceId")
  .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/quick-connects/:InstanceId',
  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({
  Name: '',
  Description: '',
  QuickConnectConfig: {QuickConnectType: '', UserConfig: '', QueueConfig: '', PhoneConfig: ''},
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/quick-connects/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    QuickConnectConfig: {QuickConnectType: '', UserConfig: '', QueueConfig: '', PhoneConfig: ''},
    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}}/quick-connects/:InstanceId');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  QuickConnectConfig: {
    QuickConnectType: '',
    UserConfig: '',
    QueueConfig: '',
    PhoneConfig: ''
  },
  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}}/quick-connects/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    QuickConnectConfig: {QuickConnectType: '', UserConfig: '', QueueConfig: '', PhoneConfig: ''},
    Tags: {}
  }
};

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

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

const url = '{{baseUrl}}/quick-connects/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","QuickConnectConfig":{"QuickConnectType":"","UserConfig":"","QueueConfig":"","PhoneConfig":""},"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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"QuickConnectConfig": @{ @"QuickConnectType": @"", @"UserConfig": @"", @"QueueConfig": @"", @"PhoneConfig": @"" },
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quick-connects/:InstanceId"]
                                                       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}}/quick-connects/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\n  },\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/quick-connects/:InstanceId",
  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([
    'Name' => '',
    'Description' => '',
    'QuickConnectConfig' => [
        'QuickConnectType' => '',
        'UserConfig' => '',
        'QueueConfig' => '',
        'PhoneConfig' => ''
    ],
    '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}}/quick-connects/:InstanceId', [
  'body' => '{
  "Name": "",
  "Description": "",
  "QuickConnectConfig": {
    "QuickConnectType": "",
    "UserConfig": "",
    "QueueConfig": "",
    "PhoneConfig": ""
  },
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quick-connects/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'QuickConnectConfig' => [
    'QuickConnectType' => '',
    'UserConfig' => '',
    'QueueConfig' => '',
    'PhoneConfig' => ''
  ],
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'QuickConnectConfig' => [
    'QuickConnectType' => '',
    'UserConfig' => '',
    'QueueConfig' => '',
    'PhoneConfig' => ''
  ],
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/quick-connects/:InstanceId');
$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}}/quick-connects/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "QuickConnectConfig": {
    "QuickConnectType": "",
    "UserConfig": "",
    "QueueConfig": "",
    "PhoneConfig": ""
  },
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quick-connects/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "QuickConnectConfig": {
    "QuickConnectType": "",
    "UserConfig": "",
    "QueueConfig": "",
    "PhoneConfig": ""
  },
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\n  },\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/quick-connects/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/quick-connects/:InstanceId"

payload = {
    "Name": "",
    "Description": "",
    "QuickConnectConfig": {
        "QuickConnectType": "",
        "UserConfig": "",
        "QueueConfig": "",
        "PhoneConfig": ""
    },
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/quick-connects/:InstanceId"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\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}}/quick-connects/:InstanceId")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\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/quick-connects/:InstanceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"QuickConnectConfig\": {\n    \"QuickConnectType\": \"\",\n    \"UserConfig\": \"\",\n    \"QueueConfig\": \"\",\n    \"PhoneConfig\": \"\"\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}}/quick-connects/:InstanceId";

    let payload = json!({
        "Name": "",
        "Description": "",
        "QuickConnectConfig": json!({
            "QuickConnectType": "",
            "UserConfig": "",
            "QueueConfig": "",
            "PhoneConfig": ""
        }),
        "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 '{
  "Name": "",
  "Description": "",
  "QuickConnectConfig": {
    "QuickConnectType": "",
    "UserConfig": "",
    "QueueConfig": "",
    "PhoneConfig": ""
  },
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/quick-connects/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "QuickConnectConfig": {\n    "QuickConnectType": "",\n    "UserConfig": "",\n    "QueueConfig": "",\n    "PhoneConfig": ""\n  },\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/quick-connects/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "QuickConnectConfig": [
    "QuickConnectType": "",
    "UserConfig": "",
    "QueueConfig": "",
    "PhoneConfig": ""
  ],
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quick-connects/:InstanceId")! 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}}/routing-profiles/:InstanceId");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/routing-profiles/:InstanceId" {:content-type :json
                                                                        :form-params {:Name ""
                                                                                      :Description ""
                                                                                      :DefaultOutboundQueueId ""
                                                                                      :QueueConfigs [{:QueueReference ""
                                                                                                      :Priority ""
                                                                                                      :Delay ""}]
                                                                                      :MediaConcurrencies [{:Channel ""
                                                                                                            :Concurrency ""
                                                                                                            :CrossChannelBehavior ""}]
                                                                                      :Tags {}}})

require "http/client"

url = "{{baseUrl}}/routing-profiles/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\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}}/routing-profiles/:InstanceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\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}}/routing-profiles/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/routing-profiles/:InstanceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\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/routing-profiles/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 310

{
  "Name": "",
  "Description": "",
  "DefaultOutboundQueueId": "",
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ],
  "MediaConcurrencies": [
    {
      "Channel": "",
      "Concurrency": "",
      "CrossChannelBehavior": ""
    }
  ],
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/routing-profiles/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/routing-profiles/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/routing-profiles/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/routing-profiles/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  DefaultOutboundQueueId: '',
  QueueConfigs: [
    {
      QueueReference: '',
      Priority: '',
      Delay: ''
    }
  ],
  MediaConcurrencies: [
    {
      Channel: '',
      Concurrency: '',
      CrossChannelBehavior: ''
    }
  ],
  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}}/routing-profiles/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/routing-profiles/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    DefaultOutboundQueueId: '',
    QueueConfigs: [{QueueReference: '', Priority: '', Delay: ''}],
    MediaConcurrencies: [{Channel: '', Concurrency: '', CrossChannelBehavior: ''}],
    Tags: {}
  }
};

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

const url = '{{baseUrl}}/routing-profiles/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","DefaultOutboundQueueId":"","QueueConfigs":[{"QueueReference":"","Priority":"","Delay":""}],"MediaConcurrencies":[{"Channel":"","Concurrency":"","CrossChannelBehavior":""}],"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}}/routing-profiles/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "DefaultOutboundQueueId": "",\n  "QueueConfigs": [\n    {\n      "QueueReference": "",\n      "Priority": "",\n      "Delay": ""\n    }\n  ],\n  "MediaConcurrencies": [\n    {\n      "Channel": "",\n      "Concurrency": "",\n      "CrossChannelBehavior": ""\n    }\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/routing-profiles/:InstanceId")
  .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/routing-profiles/:InstanceId',
  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({
  Name: '',
  Description: '',
  DefaultOutboundQueueId: '',
  QueueConfigs: [{QueueReference: '', Priority: '', Delay: ''}],
  MediaConcurrencies: [{Channel: '', Concurrency: '', CrossChannelBehavior: ''}],
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/routing-profiles/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    DefaultOutboundQueueId: '',
    QueueConfigs: [{QueueReference: '', Priority: '', Delay: ''}],
    MediaConcurrencies: [{Channel: '', Concurrency: '', CrossChannelBehavior: ''}],
    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}}/routing-profiles/:InstanceId');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  DefaultOutboundQueueId: '',
  QueueConfigs: [
    {
      QueueReference: '',
      Priority: '',
      Delay: ''
    }
  ],
  MediaConcurrencies: [
    {
      Channel: '',
      Concurrency: '',
      CrossChannelBehavior: ''
    }
  ],
  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}}/routing-profiles/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    DefaultOutboundQueueId: '',
    QueueConfigs: [{QueueReference: '', Priority: '', Delay: ''}],
    MediaConcurrencies: [{Channel: '', Concurrency: '', CrossChannelBehavior: ''}],
    Tags: {}
  }
};

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

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

const url = '{{baseUrl}}/routing-profiles/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","DefaultOutboundQueueId":"","QueueConfigs":[{"QueueReference":"","Priority":"","Delay":""}],"MediaConcurrencies":[{"Channel":"","Concurrency":"","CrossChannelBehavior":""}],"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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"DefaultOutboundQueueId": @"",
                              @"QueueConfigs": @[ @{ @"QueueReference": @"", @"Priority": @"", @"Delay": @"" } ],
                              @"MediaConcurrencies": @[ @{ @"Channel": @"", @"Concurrency": @"", @"CrossChannelBehavior": @"" } ],
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/routing-profiles/:InstanceId"]
                                                       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}}/routing-profiles/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/routing-profiles/:InstanceId",
  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([
    'Name' => '',
    'Description' => '',
    'DefaultOutboundQueueId' => '',
    'QueueConfigs' => [
        [
                'QueueReference' => '',
                'Priority' => '',
                'Delay' => ''
        ]
    ],
    'MediaConcurrencies' => [
        [
                'Channel' => '',
                'Concurrency' => '',
                'CrossChannelBehavior' => ''
        ]
    ],
    '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}}/routing-profiles/:InstanceId', [
  'body' => '{
  "Name": "",
  "Description": "",
  "DefaultOutboundQueueId": "",
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ],
  "MediaConcurrencies": [
    {
      "Channel": "",
      "Concurrency": "",
      "CrossChannelBehavior": ""
    }
  ],
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/routing-profiles/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'DefaultOutboundQueueId' => '',
  'QueueConfigs' => [
    [
        'QueueReference' => '',
        'Priority' => '',
        'Delay' => ''
    ]
  ],
  'MediaConcurrencies' => [
    [
        'Channel' => '',
        'Concurrency' => '',
        'CrossChannelBehavior' => ''
    ]
  ],
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'DefaultOutboundQueueId' => '',
  'QueueConfigs' => [
    [
        'QueueReference' => '',
        'Priority' => '',
        'Delay' => ''
    ]
  ],
  'MediaConcurrencies' => [
    [
        'Channel' => '',
        'Concurrency' => '',
        'CrossChannelBehavior' => ''
    ]
  ],
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/routing-profiles/:InstanceId');
$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}}/routing-profiles/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "DefaultOutboundQueueId": "",
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ],
  "MediaConcurrencies": [
    {
      "Channel": "",
      "Concurrency": "",
      "CrossChannelBehavior": ""
    }
  ],
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/routing-profiles/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "DefaultOutboundQueueId": "",
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ],
  "MediaConcurrencies": [
    {
      "Channel": "",
      "Concurrency": "",
      "CrossChannelBehavior": ""
    }
  ],
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\n  ],\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/routing-profiles/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/routing-profiles/:InstanceId"

payload = {
    "Name": "",
    "Description": "",
    "DefaultOutboundQueueId": "",
    "QueueConfigs": [
        {
            "QueueReference": "",
            "Priority": "",
            "Delay": ""
        }
    ],
    "MediaConcurrencies": [
        {
            "Channel": "",
            "Concurrency": "",
            "CrossChannelBehavior": ""
        }
    ],
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/routing-profiles/:InstanceId"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\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}}/routing-profiles/:InstanceId")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\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/routing-profiles/:InstanceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultOutboundQueueId\": \"\",\n  \"QueueConfigs\": [\n    {\n      \"QueueReference\": \"\",\n      \"Priority\": \"\",\n      \"Delay\": \"\"\n    }\n  ],\n  \"MediaConcurrencies\": [\n    {\n      \"Channel\": \"\",\n      \"Concurrency\": \"\",\n      \"CrossChannelBehavior\": \"\"\n    }\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}}/routing-profiles/:InstanceId";

    let payload = json!({
        "Name": "",
        "Description": "",
        "DefaultOutboundQueueId": "",
        "QueueConfigs": (
            json!({
                "QueueReference": "",
                "Priority": "",
                "Delay": ""
            })
        ),
        "MediaConcurrencies": (
            json!({
                "Channel": "",
                "Concurrency": "",
                "CrossChannelBehavior": ""
            })
        ),
        "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 '{
  "Name": "",
  "Description": "",
  "DefaultOutboundQueueId": "",
  "QueueConfigs": [
    {
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    }
  ],
  "MediaConcurrencies": [
    {
      "Channel": "",
      "Concurrency": "",
      "CrossChannelBehavior": ""
    }
  ],
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/routing-profiles/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "DefaultOutboundQueueId": "",\n  "QueueConfigs": [\n    {\n      "QueueReference": "",\n      "Priority": "",\n      "Delay": ""\n    }\n  ],\n  "MediaConcurrencies": [\n    {\n      "Channel": "",\n      "Concurrency": "",\n      "CrossChannelBehavior": ""\n    }\n  ],\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/routing-profiles/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "DefaultOutboundQueueId": "",
  "QueueConfigs": [
    [
      "QueueReference": "",
      "Priority": "",
      "Delay": ""
    ]
  ],
  "MediaConcurrencies": [
    [
      "Channel": "",
      "Concurrency": "",
      "CrossChannelBehavior": ""
    ]
  ],
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/routing-profiles/:InstanceId")! 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}}/rules/:InstanceId");

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  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/rules/:InstanceId" {:content-type :json
                                                              :form-params {:Name ""
                                                                            :TriggerEventSource {:EventSourceName ""
                                                                                                 :IntegrationAssociationId ""}
                                                                            :Function ""
                                                                            :Actions [{:ActionType ""
                                                                                       :TaskAction ""
                                                                                       :EventBridgeAction ""
                                                                                       :AssignContactCategoryAction ""
                                                                                       :SendNotificationAction ""}]
                                                                            :PublishStatus ""
                                                                            :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/rules/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\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}}/rules/:InstanceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\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}}/rules/:InstanceId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/rules/:InstanceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\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/rules/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 358

{
  "Name": "",
  "TriggerEventSource": {
    "EventSourceName": "",
    "IntegrationAssociationId": ""
  },
  "Function": "",
  "Actions": [
    {
      "ActionType": "",
      "TaskAction": "",
      "EventBridgeAction": "",
      "AssignContactCategoryAction": "",
      "SendNotificationAction": ""
    }
  ],
  "PublishStatus": "",
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rules/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rules/:InstanceId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\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  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/rules/:InstanceId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/rules/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  TriggerEventSource: {
    EventSourceName: '',
    IntegrationAssociationId: ''
  },
  Function: '',
  Actions: [
    {
      ActionType: '',
      TaskAction: '',
      EventBridgeAction: '',
      AssignContactCategoryAction: '',
      SendNotificationAction: ''
    }
  ],
  PublishStatus: '',
  ClientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rules/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    TriggerEventSource: {EventSourceName: '', IntegrationAssociationId: ''},
    Function: '',
    Actions: [
      {
        ActionType: '',
        TaskAction: '',
        EventBridgeAction: '',
        AssignContactCategoryAction: '',
        SendNotificationAction: ''
      }
    ],
    PublishStatus: '',
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/rules/:InstanceId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","TriggerEventSource":{"EventSourceName":"","IntegrationAssociationId":""},"Function":"","Actions":[{"ActionType":"","TaskAction":"","EventBridgeAction":"","AssignContactCategoryAction":"","SendNotificationAction":""}],"PublishStatus":"","ClientToken":""}'
};

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}}/rules/:InstanceId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "TriggerEventSource": {\n    "EventSourceName": "",\n    "IntegrationAssociationId": ""\n  },\n  "Function": "",\n  "Actions": [\n    {\n      "ActionType": "",\n      "TaskAction": "",\n      "EventBridgeAction": "",\n      "AssignContactCategoryAction": "",\n      "SendNotificationAction": ""\n    }\n  ],\n  "PublishStatus": "",\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/rules/:InstanceId")
  .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/rules/:InstanceId',
  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({
  Name: '',
  TriggerEventSource: {EventSourceName: '', IntegrationAssociationId: ''},
  Function: '',
  Actions: [
    {
      ActionType: '',
      TaskAction: '',
      EventBridgeAction: '',
      AssignContactCategoryAction: '',
      SendNotificationAction: ''
    }
  ],
  PublishStatus: '',
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rules/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    TriggerEventSource: {EventSourceName: '', IntegrationAssociationId: ''},
    Function: '',
    Actions: [
      {
        ActionType: '',
        TaskAction: '',
        EventBridgeAction: '',
        AssignContactCategoryAction: '',
        SendNotificationAction: ''
      }
    ],
    PublishStatus: '',
    ClientToken: ''
  },
  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}}/rules/:InstanceId');

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

req.type('json');
req.send({
  Name: '',
  TriggerEventSource: {
    EventSourceName: '',
    IntegrationAssociationId: ''
  },
  Function: '',
  Actions: [
    {
      ActionType: '',
      TaskAction: '',
      EventBridgeAction: '',
      AssignContactCategoryAction: '',
      SendNotificationAction: ''
    }
  ],
  PublishStatus: '',
  ClientToken: ''
});

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}}/rules/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    TriggerEventSource: {EventSourceName: '', IntegrationAssociationId: ''},
    Function: '',
    Actions: [
      {
        ActionType: '',
        TaskAction: '',
        EventBridgeAction: '',
        AssignContactCategoryAction: '',
        SendNotificationAction: ''
      }
    ],
    PublishStatus: '',
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/rules/:InstanceId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","TriggerEventSource":{"EventSourceName":"","IntegrationAssociationId":""},"Function":"","Actions":[{"ActionType":"","TaskAction":"","EventBridgeAction":"","AssignContactCategoryAction":"","SendNotificationAction":""}],"PublishStatus":"","ClientToken":""}'
};

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 = @{ @"Name": @"",
                              @"TriggerEventSource": @{ @"EventSourceName": @"", @"IntegrationAssociationId": @"" },
                              @"Function": @"",
                              @"Actions": @[ @{ @"ActionType": @"", @"TaskAction": @"", @"EventBridgeAction": @"", @"AssignContactCategoryAction": @"", @"SendNotificationAction": @"" } ],
                              @"PublishStatus": @"",
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rules/:InstanceId"]
                                                       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}}/rules/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/rules/:InstanceId",
  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([
    'Name' => '',
    'TriggerEventSource' => [
        'EventSourceName' => '',
        'IntegrationAssociationId' => ''
    ],
    'Function' => '',
    'Actions' => [
        [
                'ActionType' => '',
                'TaskAction' => '',
                'EventBridgeAction' => '',
                'AssignContactCategoryAction' => '',
                'SendNotificationAction' => ''
        ]
    ],
    'PublishStatus' => '',
    'ClientToken' => ''
  ]),
  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}}/rules/:InstanceId', [
  'body' => '{
  "Name": "",
  "TriggerEventSource": {
    "EventSourceName": "",
    "IntegrationAssociationId": ""
  },
  "Function": "",
  "Actions": [
    {
      "ActionType": "",
      "TaskAction": "",
      "EventBridgeAction": "",
      "AssignContactCategoryAction": "",
      "SendNotificationAction": ""
    }
  ],
  "PublishStatus": "",
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'TriggerEventSource' => [
    'EventSourceName' => '',
    'IntegrationAssociationId' => ''
  ],
  'Function' => '',
  'Actions' => [
    [
        'ActionType' => '',
        'TaskAction' => '',
        'EventBridgeAction' => '',
        'AssignContactCategoryAction' => '',
        'SendNotificationAction' => ''
    ]
  ],
  'PublishStatus' => '',
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'TriggerEventSource' => [
    'EventSourceName' => '',
    'IntegrationAssociationId' => ''
  ],
  'Function' => '',
  'Actions' => [
    [
        'ActionType' => '',
        'TaskAction' => '',
        'EventBridgeAction' => '',
        'AssignContactCategoryAction' => '',
        'SendNotificationAction' => ''
    ]
  ],
  'PublishStatus' => '',
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/rules/:InstanceId');
$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}}/rules/:InstanceId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "TriggerEventSource": {
    "EventSourceName": "",
    "IntegrationAssociationId": ""
  },
  "Function": "",
  "Actions": [
    {
      "ActionType": "",
      "TaskAction": "",
      "EventBridgeAction": "",
      "AssignContactCategoryAction": "",
      "SendNotificationAction": ""
    }
  ],
  "PublishStatus": "",
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/rules/:InstanceId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "TriggerEventSource": {
    "EventSourceName": "",
    "IntegrationAssociationId": ""
  },
  "Function": "",
  "Actions": [
    {
      "ActionType": "",
      "TaskAction": "",
      "EventBridgeAction": "",
      "AssignContactCategoryAction": "",
      "SendNotificationAction": ""
    }
  ],
  "PublishStatus": "",
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/rules/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/rules/:InstanceId"

payload = {
    "Name": "",
    "TriggerEventSource": {
        "EventSourceName": "",
        "IntegrationAssociationId": ""
    },
    "Function": "",
    "Actions": [
        {
            "ActionType": "",
            "TaskAction": "",
            "EventBridgeAction": "",
            "AssignContactCategoryAction": "",
            "SendNotificationAction": ""
        }
    ],
    "PublishStatus": "",
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/rules/:InstanceId"

payload <- "{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\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}}/rules/:InstanceId")

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  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\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/rules/:InstanceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"TriggerEventSource\": {\n    \"EventSourceName\": \"\",\n    \"IntegrationAssociationId\": \"\"\n  },\n  \"Function\": \"\",\n  \"Actions\": [\n    {\n      \"ActionType\": \"\",\n      \"TaskAction\": \"\",\n      \"EventBridgeAction\": \"\",\n      \"AssignContactCategoryAction\": \"\",\n      \"SendNotificationAction\": \"\"\n    }\n  ],\n  \"PublishStatus\": \"\",\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "TriggerEventSource": json!({
            "EventSourceName": "",
            "IntegrationAssociationId": ""
        }),
        "Function": "",
        "Actions": (
            json!({
                "ActionType": "",
                "TaskAction": "",
                "EventBridgeAction": "",
                "AssignContactCategoryAction": "",
                "SendNotificationAction": ""
            })
        ),
        "PublishStatus": "",
        "ClientToken": ""
    });

    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 '{
  "Name": "",
  "TriggerEventSource": {
    "EventSourceName": "",
    "IntegrationAssociationId": ""
  },
  "Function": "",
  "Actions": [
    {
      "ActionType": "",
      "TaskAction": "",
      "EventBridgeAction": "",
      "AssignContactCategoryAction": "",
      "SendNotificationAction": ""
    }
  ],
  "PublishStatus": "",
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/rules/:InstanceId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "TriggerEventSource": {\n    "EventSourceName": "",\n    "IntegrationAssociationId": ""\n  },\n  "Function": "",\n  "Actions": [\n    {\n      "ActionType": "",\n      "TaskAction": "",\n      "EventBridgeAction": "",\n      "AssignContactCategoryAction": "",\n      "SendNotificationAction": ""\n    }\n  ],\n  "PublishStatus": "",\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/rules/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "TriggerEventSource": [
    "EventSourceName": "",
    "IntegrationAssociationId": ""
  ],
  "Function": "",
  "Actions": [
    [
      "ActionType": "",
      "TaskAction": "",
      "EventBridgeAction": "",
      "AssignContactCategoryAction": "",
      "SendNotificationAction": ""
    ]
  ],
  "PublishStatus": "",
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rules/:InstanceId")! 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}}/security-profiles/:InstanceId");

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  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/security-profiles/:InstanceId" {:content-type :json
                                                                         :form-params {:SecurityProfileName ""
                                                                                       :Description ""
                                                                                       :Permissions []
                                                                                       :Tags {}
                                                                                       :AllowedAccessControlTags {}
                                                                                       :TagRestrictedResources []}})

require "http/client"

url = "{{baseUrl}}/security-profiles/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\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}}/security-profiles/:InstanceId"),
    Content = new StringContent("{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\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}}/security-profiles/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/security-profiles/:InstanceId"

	payload := strings.NewReader("{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\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/security-profiles/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 153

{
  "SecurityProfileName": "",
  "Description": "",
  "Permissions": [],
  "Tags": {},
  "AllowedAccessControlTags": {},
  "TagRestrictedResources": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/security-profiles/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/security-profiles/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\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  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/security-profiles/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/security-profiles/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\n}")
  .asString();

const data = JSON.stringify({
  SecurityProfileName: '',
  Description: '',
  Permissions: [],
  Tags: {},
  AllowedAccessControlTags: {},
  TagRestrictedResources: []
});

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

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

xhr.open('PUT', '{{baseUrl}}/security-profiles/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/security-profiles/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    SecurityProfileName: '',
    Description: '',
    Permissions: [],
    Tags: {},
    AllowedAccessControlTags: {},
    TagRestrictedResources: []
  }
};

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

const url = '{{baseUrl}}/security-profiles/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"SecurityProfileName":"","Description":"","Permissions":[],"Tags":{},"AllowedAccessControlTags":{},"TagRestrictedResources":[]}'
};

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}}/security-profiles/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SecurityProfileName": "",\n  "Description": "",\n  "Permissions": [],\n  "Tags": {},\n  "AllowedAccessControlTags": {},\n  "TagRestrictedResources": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/security-profiles/:InstanceId")
  .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/security-profiles/:InstanceId',
  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({
  SecurityProfileName: '',
  Description: '',
  Permissions: [],
  Tags: {},
  AllowedAccessControlTags: {},
  TagRestrictedResources: []
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/security-profiles/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {
    SecurityProfileName: '',
    Description: '',
    Permissions: [],
    Tags: {},
    AllowedAccessControlTags: {},
    TagRestrictedResources: []
  },
  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}}/security-profiles/:InstanceId');

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

req.type('json');
req.send({
  SecurityProfileName: '',
  Description: '',
  Permissions: [],
  Tags: {},
  AllowedAccessControlTags: {},
  TagRestrictedResources: []
});

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}}/security-profiles/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    SecurityProfileName: '',
    Description: '',
    Permissions: [],
    Tags: {},
    AllowedAccessControlTags: {},
    TagRestrictedResources: []
  }
};

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

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

const url = '{{baseUrl}}/security-profiles/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"SecurityProfileName":"","Description":"","Permissions":[],"Tags":{},"AllowedAccessControlTags":{},"TagRestrictedResources":[]}'
};

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 = @{ @"SecurityProfileName": @"",
                              @"Description": @"",
                              @"Permissions": @[  ],
                              @"Tags": @{  },
                              @"AllowedAccessControlTags": @{  },
                              @"TagRestrictedResources": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/security-profiles/:InstanceId"]
                                                       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}}/security-profiles/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\n}" in

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

 "{{baseUrl}}/security-profiles/:InstanceId",
  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([
    'SecurityProfileName' => '',
    'Description' => '',
    'Permissions' => [
        
    ],
    'Tags' => [
        
    ],
    'AllowedAccessControlTags' => [
        
    ],
    'TagRestrictedResources' => [
        
    ]
  ]),
  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}}/security-profiles/:InstanceId', [
  'body' => '{
  "SecurityProfileName": "",
  "Description": "",
  "Permissions": [],
  "Tags": {},
  "AllowedAccessControlTags": {},
  "TagRestrictedResources": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/security-profiles/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SecurityProfileName' => '',
  'Description' => '',
  'Permissions' => [
    
  ],
  'Tags' => [
    
  ],
  'AllowedAccessControlTags' => [
    
  ],
  'TagRestrictedResources' => [
    
  ]
]));

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

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

append(json_encode([
  'SecurityProfileName' => '',
  'Description' => '',
  'Permissions' => [
    
  ],
  'Tags' => [
    
  ],
  'AllowedAccessControlTags' => [
    
  ],
  'TagRestrictedResources' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/security-profiles/:InstanceId');
$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}}/security-profiles/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "SecurityProfileName": "",
  "Description": "",
  "Permissions": [],
  "Tags": {},
  "AllowedAccessControlTags": {},
  "TagRestrictedResources": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/security-profiles/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "SecurityProfileName": "",
  "Description": "",
  "Permissions": [],
  "Tags": {},
  "AllowedAccessControlTags": {},
  "TagRestrictedResources": []
}'

import http.client

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

payload = "{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\n}"

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

conn.request("PUT", "/baseUrl/security-profiles/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/security-profiles/:InstanceId"

payload = {
    "SecurityProfileName": "",
    "Description": "",
    "Permissions": [],
    "Tags": {},
    "AllowedAccessControlTags": {},
    "TagRestrictedResources": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/security-profiles/:InstanceId"

payload <- "{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\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}}/security-profiles/:InstanceId")

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  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\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/security-profiles/:InstanceId') do |req|
  req.body = "{\n  \"SecurityProfileName\": \"\",\n  \"Description\": \"\",\n  \"Permissions\": [],\n  \"Tags\": {},\n  \"AllowedAccessControlTags\": {},\n  \"TagRestrictedResources\": []\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}}/security-profiles/:InstanceId";

    let payload = json!({
        "SecurityProfileName": "",
        "Description": "",
        "Permissions": (),
        "Tags": json!({}),
        "AllowedAccessControlTags": json!({}),
        "TagRestrictedResources": ()
    });

    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 '{
  "SecurityProfileName": "",
  "Description": "",
  "Permissions": [],
  "Tags": {},
  "AllowedAccessControlTags": {},
  "TagRestrictedResources": []
}' |  \
  http PUT {{baseUrl}}/security-profiles/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "SecurityProfileName": "",\n  "Description": "",\n  "Permissions": [],\n  "Tags": {},\n  "AllowedAccessControlTags": {},\n  "TagRestrictedResources": []\n}' \
  --output-document \
  - {{baseUrl}}/security-profiles/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "SecurityProfileName": "",
  "Description": "",
  "Permissions": [],
  "Tags": [],
  "AllowedAccessControlTags": [],
  "TagRestrictedResources": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/security-profiles/:InstanceId")! 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}}/instance/:InstanceId/task/template");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance/:InstanceId/task/template" {:content-type :json
                                                                              :form-params {:Name ""
                                                                                            :Description ""
                                                                                            :ContactFlowId ""
                                                                                            :Constraints {:RequiredFields ""
                                                                                                          :ReadOnlyFields ""
                                                                                                          :InvisibleFields ""}
                                                                                            :Defaults {:DefaultFieldValues ""}
                                                                                            :Status ""
                                                                                            :Fields [{:Id ""
                                                                                                      :Description ""
                                                                                                      :Type ""
                                                                                                      :SingleSelectOptions ""}]
                                                                                            :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/task/template"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/instance/:InstanceId/task/template"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/instance/:InstanceId/task/template");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/task/template"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/instance/:InstanceId/task/template HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 371

{
  "Name": "",
  "Description": "",
  "ContactFlowId": "",
  "Constraints": {
    "RequiredFields": "",
    "ReadOnlyFields": "",
    "InvisibleFields": ""
  },
  "Defaults": {
    "DefaultFieldValues": ""
  },
  "Status": "",
  "Fields": [
    {
      "Id": "",
      "Description": "",
      "Type": "",
      "SingleSelectOptions": ""
    }
  ],
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance/:InstanceId/task/template")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/task/template"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/task/template")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance/:InstanceId/task/template")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  ContactFlowId: '',
  Constraints: {
    RequiredFields: '',
    ReadOnlyFields: '',
    InvisibleFields: ''
  },
  Defaults: {
    DefaultFieldValues: ''
  },
  Status: '',
  Fields: [
    {
      Id: '',
      Description: '',
      Type: '',
      SingleSelectOptions: ''
    }
  ],
  ClientToken: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/instance/:InstanceId/task/template');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/task/template',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    ContactFlowId: '',
    Constraints: {RequiredFields: '', ReadOnlyFields: '', InvisibleFields: ''},
    Defaults: {DefaultFieldValues: ''},
    Status: '',
    Fields: [{Id: '', Description: '', Type: '', SingleSelectOptions: ''}],
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/instance/:InstanceId/task/template';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","ContactFlowId":"","Constraints":{"RequiredFields":"","ReadOnlyFields":"","InvisibleFields":""},"Defaults":{"DefaultFieldValues":""},"Status":"","Fields":[{"Id":"","Description":"","Type":"","SingleSelectOptions":""}],"ClientToken":""}'
};

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}}/instance/:InstanceId/task/template',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "ContactFlowId": "",\n  "Constraints": {\n    "RequiredFields": "",\n    "ReadOnlyFields": "",\n    "InvisibleFields": ""\n  },\n  "Defaults": {\n    "DefaultFieldValues": ""\n  },\n  "Status": "",\n  "Fields": [\n    {\n      "Id": "",\n      "Description": "",\n      "Type": "",\n      "SingleSelectOptions": ""\n    }\n  ],\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/task/template")
  .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/instance/:InstanceId/task/template',
  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({
  Name: '',
  Description: '',
  ContactFlowId: '',
  Constraints: {RequiredFields: '', ReadOnlyFields: '', InvisibleFields: ''},
  Defaults: {DefaultFieldValues: ''},
  Status: '',
  Fields: [{Id: '', Description: '', Type: '', SingleSelectOptions: ''}],
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/task/template',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    ContactFlowId: '',
    Constraints: {RequiredFields: '', ReadOnlyFields: '', InvisibleFields: ''},
    Defaults: {DefaultFieldValues: ''},
    Status: '',
    Fields: [{Id: '', Description: '', Type: '', SingleSelectOptions: ''}],
    ClientToken: ''
  },
  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}}/instance/:InstanceId/task/template');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  ContactFlowId: '',
  Constraints: {
    RequiredFields: '',
    ReadOnlyFields: '',
    InvisibleFields: ''
  },
  Defaults: {
    DefaultFieldValues: ''
  },
  Status: '',
  Fields: [
    {
      Id: '',
      Description: '',
      Type: '',
      SingleSelectOptions: ''
    }
  ],
  ClientToken: ''
});

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}}/instance/:InstanceId/task/template',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    ContactFlowId: '',
    Constraints: {RequiredFields: '', ReadOnlyFields: '', InvisibleFields: ''},
    Defaults: {DefaultFieldValues: ''},
    Status: '',
    Fields: [{Id: '', Description: '', Type: '', SingleSelectOptions: ''}],
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/task/template';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","ContactFlowId":"","Constraints":{"RequiredFields":"","ReadOnlyFields":"","InvisibleFields":""},"Defaults":{"DefaultFieldValues":""},"Status":"","Fields":[{"Id":"","Description":"","Type":"","SingleSelectOptions":""}],"ClientToken":""}'
};

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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"ContactFlowId": @"",
                              @"Constraints": @{ @"RequiredFields": @"", @"ReadOnlyFields": @"", @"InvisibleFields": @"" },
                              @"Defaults": @{ @"DefaultFieldValues": @"" },
                              @"Status": @"",
                              @"Fields": @[ @{ @"Id": @"", @"Description": @"", @"Type": @"", @"SingleSelectOptions": @"" } ],
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/instance/:InstanceId/task/template"]
                                                       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}}/instance/:InstanceId/task/template" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/instance/:InstanceId/task/template",
  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([
    'Name' => '',
    'Description' => '',
    'ContactFlowId' => '',
    'Constraints' => [
        'RequiredFields' => '',
        'ReadOnlyFields' => '',
        'InvisibleFields' => ''
    ],
    'Defaults' => [
        'DefaultFieldValues' => ''
    ],
    'Status' => '',
    'Fields' => [
        [
                'Id' => '',
                'Description' => '',
                'Type' => '',
                'SingleSelectOptions' => ''
        ]
    ],
    'ClientToken' => ''
  ]),
  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}}/instance/:InstanceId/task/template', [
  'body' => '{
  "Name": "",
  "Description": "",
  "ContactFlowId": "",
  "Constraints": {
    "RequiredFields": "",
    "ReadOnlyFields": "",
    "InvisibleFields": ""
  },
  "Defaults": {
    "DefaultFieldValues": ""
  },
  "Status": "",
  "Fields": [
    {
      "Id": "",
      "Description": "",
      "Type": "",
      "SingleSelectOptions": ""
    }
  ],
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/task/template');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'ContactFlowId' => '',
  'Constraints' => [
    'RequiredFields' => '',
    'ReadOnlyFields' => '',
    'InvisibleFields' => ''
  ],
  'Defaults' => [
    'DefaultFieldValues' => ''
  ],
  'Status' => '',
  'Fields' => [
    [
        'Id' => '',
        'Description' => '',
        'Type' => '',
        'SingleSelectOptions' => ''
    ]
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'ContactFlowId' => '',
  'Constraints' => [
    'RequiredFields' => '',
    'ReadOnlyFields' => '',
    'InvisibleFields' => ''
  ],
  'Defaults' => [
    'DefaultFieldValues' => ''
  ],
  'Status' => '',
  'Fields' => [
    [
        'Id' => '',
        'Description' => '',
        'Type' => '',
        'SingleSelectOptions' => ''
    ]
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/instance/:InstanceId/task/template');
$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}}/instance/:InstanceId/task/template' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "ContactFlowId": "",
  "Constraints": {
    "RequiredFields": "",
    "ReadOnlyFields": "",
    "InvisibleFields": ""
  },
  "Defaults": {
    "DefaultFieldValues": ""
  },
  "Status": "",
  "Fields": [
    {
      "Id": "",
      "Description": "",
      "Type": "",
      "SingleSelectOptions": ""
    }
  ],
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/task/template' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "ContactFlowId": "",
  "Constraints": {
    "RequiredFields": "",
    "ReadOnlyFields": "",
    "InvisibleFields": ""
  },
  "Defaults": {
    "DefaultFieldValues": ""
  },
  "Status": "",
  "Fields": [
    {
      "Id": "",
      "Description": "",
      "Type": "",
      "SingleSelectOptions": ""
    }
  ],
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/instance/:InstanceId/task/template", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/task/template"

payload = {
    "Name": "",
    "Description": "",
    "ContactFlowId": "",
    "Constraints": {
        "RequiredFields": "",
        "ReadOnlyFields": "",
        "InvisibleFields": ""
    },
    "Defaults": { "DefaultFieldValues": "" },
    "Status": "",
    "Fields": [
        {
            "Id": "",
            "Description": "",
            "Type": "",
            "SingleSelectOptions": ""
        }
    ],
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/task/template"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/instance/:InstanceId/task/template")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/instance/:InstanceId/task/template') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ContactFlowId\": \"\",\n  \"Constraints\": {\n    \"RequiredFields\": \"\",\n    \"ReadOnlyFields\": \"\",\n    \"InvisibleFields\": \"\"\n  },\n  \"Defaults\": {\n    \"DefaultFieldValues\": \"\"\n  },\n  \"Status\": \"\",\n  \"Fields\": [\n    {\n      \"Id\": \"\",\n      \"Description\": \"\",\n      \"Type\": \"\",\n      \"SingleSelectOptions\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/instance/:InstanceId/task/template";

    let payload = json!({
        "Name": "",
        "Description": "",
        "ContactFlowId": "",
        "Constraints": json!({
            "RequiredFields": "",
            "ReadOnlyFields": "",
            "InvisibleFields": ""
        }),
        "Defaults": json!({"DefaultFieldValues": ""}),
        "Status": "",
        "Fields": (
            json!({
                "Id": "",
                "Description": "",
                "Type": "",
                "SingleSelectOptions": ""
            })
        ),
        "ClientToken": ""
    });

    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 '{
  "Name": "",
  "Description": "",
  "ContactFlowId": "",
  "Constraints": {
    "RequiredFields": "",
    "ReadOnlyFields": "",
    "InvisibleFields": ""
  },
  "Defaults": {
    "DefaultFieldValues": ""
  },
  "Status": "",
  "Fields": [
    {
      "Id": "",
      "Description": "",
      "Type": "",
      "SingleSelectOptions": ""
    }
  ],
  "ClientToken": ""
}' |  \
  http PUT {{baseUrl}}/instance/:InstanceId/task/template \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "ContactFlowId": "",\n  "Constraints": {\n    "RequiredFields": "",\n    "ReadOnlyFields": "",\n    "InvisibleFields": ""\n  },\n  "Defaults": {\n    "DefaultFieldValues": ""\n  },\n  "Status": "",\n  "Fields": [\n    {\n      "Id": "",\n      "Description": "",\n      "Type": "",\n      "SingleSelectOptions": ""\n    }\n  ],\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/task/template

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "ContactFlowId": "",
  "Constraints": [
    "RequiredFields": "",
    "ReadOnlyFields": "",
    "InvisibleFields": ""
  ],
  "Defaults": ["DefaultFieldValues": ""],
  "Status": "",
  "Fields": [
    [
      "Id": "",
      "Description": "",
      "Type": "",
      "SingleSelectOptions": ""
    ]
  ],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/task/template")! 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}}/traffic-distribution-group");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/traffic-distribution-group" {:content-type :json
                                                                      :form-params {:Name ""
                                                                                    :Description ""
                                                                                    :InstanceId ""
                                                                                    :ClientToken ""
                                                                                    :Tags {}}})

require "http/client"

url = "{{baseUrl}}/traffic-distribution-group"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\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}}/traffic-distribution-group"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\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}}/traffic-distribution-group");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/traffic-distribution-group"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\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/traffic-distribution-group HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "Name": "",
  "Description": "",
  "InstanceId": "",
  "ClientToken": "",
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/traffic-distribution-group")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/traffic-distribution-group"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/traffic-distribution-group")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/traffic-distribution-group")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  InstanceId: '',
  ClientToken: '',
  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}}/traffic-distribution-group');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/traffic-distribution-group',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', InstanceId: '', ClientToken: '', Tags: {}}
};

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

const url = '{{baseUrl}}/traffic-distribution-group';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","InstanceId":"","ClientToken":"","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}}/traffic-distribution-group',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "InstanceId": "",\n  "ClientToken": "",\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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/traffic-distribution-group")
  .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/traffic-distribution-group',
  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({Name: '', Description: '', InstanceId: '', ClientToken: '', Tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/traffic-distribution-group',
  headers: {'content-type': 'application/json'},
  body: {Name: '', Description: '', InstanceId: '', ClientToken: '', 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}}/traffic-distribution-group');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  InstanceId: '',
  ClientToken: '',
  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}}/traffic-distribution-group',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', InstanceId: '', ClientToken: '', Tags: {}}
};

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

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

const url = '{{baseUrl}}/traffic-distribution-group';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","InstanceId":"","ClientToken":"","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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"InstanceId": @"",
                              @"ClientToken": @"",
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/traffic-distribution-group"]
                                                       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}}/traffic-distribution-group" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/traffic-distribution-group",
  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([
    'Name' => '',
    'Description' => '',
    'InstanceId' => '',
    'ClientToken' => '',
    '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}}/traffic-distribution-group', [
  'body' => '{
  "Name": "",
  "Description": "",
  "InstanceId": "",
  "ClientToken": "",
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/traffic-distribution-group');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'InstanceId' => '',
  'ClientToken' => '',
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'InstanceId' => '',
  'ClientToken' => '',
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/traffic-distribution-group');
$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}}/traffic-distribution-group' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "InstanceId": "",
  "ClientToken": "",
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/traffic-distribution-group' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "InstanceId": "",
  "ClientToken": "",
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/traffic-distribution-group", payload, headers)

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

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

import requests

url = "{{baseUrl}}/traffic-distribution-group"

payload = {
    "Name": "",
    "Description": "",
    "InstanceId": "",
    "ClientToken": "",
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/traffic-distribution-group"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\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}}/traffic-distribution-group")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\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/traffic-distribution-group') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InstanceId\": \"\",\n  \"ClientToken\": \"\",\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}}/traffic-distribution-group";

    let payload = json!({
        "Name": "",
        "Description": "",
        "InstanceId": "",
        "ClientToken": "",
        "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 '{
  "Name": "",
  "Description": "",
  "InstanceId": "",
  "ClientToken": "",
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/traffic-distribution-group \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "InstanceId": "",\n  "ClientToken": "",\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/traffic-distribution-group

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "InstanceId": "",
  "ClientToken": "",
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/traffic-distribution-group")! 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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases");

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  \"UseCaseType\": \"\",\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases" {:content-type :json
                                                                                                                             :form-params {:UseCaseType ""
                                                                                                                                           :Tags {}}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"UseCaseType\": \"\",\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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases"),
    Content = new StringContent("{\n  \"UseCaseType\": \"\",\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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UseCaseType\": \"\",\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases"

	payload := strings.NewReader("{\n  \"UseCaseType\": \"\",\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/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "UseCaseType": "",
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UseCaseType\": \"\",\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"UseCaseType\": \"\",\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  \"UseCaseType\": \"\",\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases")
  .header("content-type", "application/json")
  .body("{\n  \"UseCaseType\": \"\",\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  UseCaseType: '',
  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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases',
  headers: {'content-type': 'application/json'},
  data: {UseCaseType: '', Tags: {}}
};

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

const url = '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"UseCaseType":"","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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UseCaseType": "",\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  \"UseCaseType\": \"\",\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases")
  .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/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases',
  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({UseCaseType: '', Tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases',
  headers: {'content-type': 'application/json'},
  body: {UseCaseType: '', 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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases');

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

req.type('json');
req.send({
  UseCaseType: '',
  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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases',
  headers: {'content-type': 'application/json'},
  data: {UseCaseType: '', Tags: {}}
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"UseCaseType":"","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 = @{ @"UseCaseType": @"",
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases"]
                                                       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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"UseCaseType\": \"\",\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases",
  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([
    'UseCaseType' => '',
    '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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases', [
  'body' => '{
  "UseCaseType": "",
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'UseCaseType' => '',
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases');
$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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "UseCaseType": "",
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "UseCaseType": "",
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"UseCaseType\": \"\",\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases", payload, headers)

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases"

payload = {
    "UseCaseType": "",
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases"

payload <- "{\n  \"UseCaseType\": \"\",\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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases")

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  \"UseCaseType\": \"\",\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/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases') do |req|
  req.body = "{\n  \"UseCaseType\": \"\",\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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases";

    let payload = json!({
        "UseCaseType": "",
        "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 '{
  "UseCaseType": "",
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "UseCaseType": "",\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases")! 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}}/users/:InstanceId");

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  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/users/:InstanceId" {:content-type :json
                                                             :form-params {:Username ""
                                                                           :Password ""
                                                                           :IdentityInfo {:FirstName ""
                                                                                          :LastName ""
                                                                                          :Email ""
                                                                                          :SecondaryEmail ""
                                                                                          :Mobile ""}
                                                                           :PhoneConfig {:PhoneType ""
                                                                                         :AutoAccept ""
                                                                                         :AfterContactWorkTimeLimit ""
                                                                                         :DeskPhoneNumber ""}
                                                                           :DirectoryUserId ""
                                                                           :SecurityProfileIds []
                                                                           :RoutingProfileId ""
                                                                           :HierarchyGroupId ""
                                                                           :Tags {}}})

require "http/client"

url = "{{baseUrl}}/users/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\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}}/users/:InstanceId"),
    Content = new StringContent("{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\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}}/users/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/users/:InstanceId"

	payload := strings.NewReader("{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\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/users/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 413

{
  "Username": "",
  "Password": "",
  "IdentityInfo": {
    "FirstName": "",
    "LastName": "",
    "Email": "",
    "SecondaryEmail": "",
    "Mobile": ""
  },
  "PhoneConfig": {
    "PhoneType": "",
    "AutoAccept": "",
    "AfterContactWorkTimeLimit": "",
    "DeskPhoneNumber": ""
  },
  "DirectoryUserId": "",
  "SecurityProfileIds": [],
  "RoutingProfileId": "",
  "HierarchyGroupId": "",
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/users/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/users/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\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  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/users/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/users/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Username: '',
  Password: '',
  IdentityInfo: {
    FirstName: '',
    LastName: '',
    Email: '',
    SecondaryEmail: '',
    Mobile: ''
  },
  PhoneConfig: {
    PhoneType: '',
    AutoAccept: '',
    AfterContactWorkTimeLimit: '',
    DeskPhoneNumber: ''
  },
  DirectoryUserId: '',
  SecurityProfileIds: [],
  RoutingProfileId: '',
  HierarchyGroupId: '',
  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}}/users/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/users/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Username: '',
    Password: '',
    IdentityInfo: {FirstName: '', LastName: '', Email: '', SecondaryEmail: '', Mobile: ''},
    PhoneConfig: {
      PhoneType: '',
      AutoAccept: '',
      AfterContactWorkTimeLimit: '',
      DeskPhoneNumber: ''
    },
    DirectoryUserId: '',
    SecurityProfileIds: [],
    RoutingProfileId: '',
    HierarchyGroupId: '',
    Tags: {}
  }
};

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

const url = '{{baseUrl}}/users/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Username":"","Password":"","IdentityInfo":{"FirstName":"","LastName":"","Email":"","SecondaryEmail":"","Mobile":""},"PhoneConfig":{"PhoneType":"","AutoAccept":"","AfterContactWorkTimeLimit":"","DeskPhoneNumber":""},"DirectoryUserId":"","SecurityProfileIds":[],"RoutingProfileId":"","HierarchyGroupId":"","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}}/users/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Username": "",\n  "Password": "",\n  "IdentityInfo": {\n    "FirstName": "",\n    "LastName": "",\n    "Email": "",\n    "SecondaryEmail": "",\n    "Mobile": ""\n  },\n  "PhoneConfig": {\n    "PhoneType": "",\n    "AutoAccept": "",\n    "AfterContactWorkTimeLimit": "",\n    "DeskPhoneNumber": ""\n  },\n  "DirectoryUserId": "",\n  "SecurityProfileIds": [],\n  "RoutingProfileId": "",\n  "HierarchyGroupId": "",\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  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/users/:InstanceId")
  .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/users/:InstanceId',
  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({
  Username: '',
  Password: '',
  IdentityInfo: {FirstName: '', LastName: '', Email: '', SecondaryEmail: '', Mobile: ''},
  PhoneConfig: {
    PhoneType: '',
    AutoAccept: '',
    AfterContactWorkTimeLimit: '',
    DeskPhoneNumber: ''
  },
  DirectoryUserId: '',
  SecurityProfileIds: [],
  RoutingProfileId: '',
  HierarchyGroupId: '',
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/users/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {
    Username: '',
    Password: '',
    IdentityInfo: {FirstName: '', LastName: '', Email: '', SecondaryEmail: '', Mobile: ''},
    PhoneConfig: {
      PhoneType: '',
      AutoAccept: '',
      AfterContactWorkTimeLimit: '',
      DeskPhoneNumber: ''
    },
    DirectoryUserId: '',
    SecurityProfileIds: [],
    RoutingProfileId: '',
    HierarchyGroupId: '',
    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}}/users/:InstanceId');

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

req.type('json');
req.send({
  Username: '',
  Password: '',
  IdentityInfo: {
    FirstName: '',
    LastName: '',
    Email: '',
    SecondaryEmail: '',
    Mobile: ''
  },
  PhoneConfig: {
    PhoneType: '',
    AutoAccept: '',
    AfterContactWorkTimeLimit: '',
    DeskPhoneNumber: ''
  },
  DirectoryUserId: '',
  SecurityProfileIds: [],
  RoutingProfileId: '',
  HierarchyGroupId: '',
  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}}/users/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {
    Username: '',
    Password: '',
    IdentityInfo: {FirstName: '', LastName: '', Email: '', SecondaryEmail: '', Mobile: ''},
    PhoneConfig: {
      PhoneType: '',
      AutoAccept: '',
      AfterContactWorkTimeLimit: '',
      DeskPhoneNumber: ''
    },
    DirectoryUserId: '',
    SecurityProfileIds: [],
    RoutingProfileId: '',
    HierarchyGroupId: '',
    Tags: {}
  }
};

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

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

const url = '{{baseUrl}}/users/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Username":"","Password":"","IdentityInfo":{"FirstName":"","LastName":"","Email":"","SecondaryEmail":"","Mobile":""},"PhoneConfig":{"PhoneType":"","AutoAccept":"","AfterContactWorkTimeLimit":"","DeskPhoneNumber":""},"DirectoryUserId":"","SecurityProfileIds":[],"RoutingProfileId":"","HierarchyGroupId":"","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 = @{ @"Username": @"",
                              @"Password": @"",
                              @"IdentityInfo": @{ @"FirstName": @"", @"LastName": @"", @"Email": @"", @"SecondaryEmail": @"", @"Mobile": @"" },
                              @"PhoneConfig": @{ @"PhoneType": @"", @"AutoAccept": @"", @"AfterContactWorkTimeLimit": @"", @"DeskPhoneNumber": @"" },
                              @"DirectoryUserId": @"",
                              @"SecurityProfileIds": @[  ],
                              @"RoutingProfileId": @"",
                              @"HierarchyGroupId": @"",
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:InstanceId"]
                                                       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}}/users/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/users/:InstanceId",
  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([
    'Username' => '',
    'Password' => '',
    'IdentityInfo' => [
        'FirstName' => '',
        'LastName' => '',
        'Email' => '',
        'SecondaryEmail' => '',
        'Mobile' => ''
    ],
    'PhoneConfig' => [
        'PhoneType' => '',
        'AutoAccept' => '',
        'AfterContactWorkTimeLimit' => '',
        'DeskPhoneNumber' => ''
    ],
    'DirectoryUserId' => '',
    'SecurityProfileIds' => [
        
    ],
    'RoutingProfileId' => '',
    'HierarchyGroupId' => '',
    '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}}/users/:InstanceId', [
  'body' => '{
  "Username": "",
  "Password": "",
  "IdentityInfo": {
    "FirstName": "",
    "LastName": "",
    "Email": "",
    "SecondaryEmail": "",
    "Mobile": ""
  },
  "PhoneConfig": {
    "PhoneType": "",
    "AutoAccept": "",
    "AfterContactWorkTimeLimit": "",
    "DeskPhoneNumber": ""
  },
  "DirectoryUserId": "",
  "SecurityProfileIds": [],
  "RoutingProfileId": "",
  "HierarchyGroupId": "",
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/users/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Username' => '',
  'Password' => '',
  'IdentityInfo' => [
    'FirstName' => '',
    'LastName' => '',
    'Email' => '',
    'SecondaryEmail' => '',
    'Mobile' => ''
  ],
  'PhoneConfig' => [
    'PhoneType' => '',
    'AutoAccept' => '',
    'AfterContactWorkTimeLimit' => '',
    'DeskPhoneNumber' => ''
  ],
  'DirectoryUserId' => '',
  'SecurityProfileIds' => [
    
  ],
  'RoutingProfileId' => '',
  'HierarchyGroupId' => '',
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Username' => '',
  'Password' => '',
  'IdentityInfo' => [
    'FirstName' => '',
    'LastName' => '',
    'Email' => '',
    'SecondaryEmail' => '',
    'Mobile' => ''
  ],
  'PhoneConfig' => [
    'PhoneType' => '',
    'AutoAccept' => '',
    'AfterContactWorkTimeLimit' => '',
    'DeskPhoneNumber' => ''
  ],
  'DirectoryUserId' => '',
  'SecurityProfileIds' => [
    
  ],
  'RoutingProfileId' => '',
  'HierarchyGroupId' => '',
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/users/:InstanceId');
$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}}/users/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Username": "",
  "Password": "",
  "IdentityInfo": {
    "FirstName": "",
    "LastName": "",
    "Email": "",
    "SecondaryEmail": "",
    "Mobile": ""
  },
  "PhoneConfig": {
    "PhoneType": "",
    "AutoAccept": "",
    "AfterContactWorkTimeLimit": "",
    "DeskPhoneNumber": ""
  },
  "DirectoryUserId": "",
  "SecurityProfileIds": [],
  "RoutingProfileId": "",
  "HierarchyGroupId": "",
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Username": "",
  "Password": "",
  "IdentityInfo": {
    "FirstName": "",
    "LastName": "",
    "Email": "",
    "SecondaryEmail": "",
    "Mobile": ""
  },
  "PhoneConfig": {
    "PhoneType": "",
    "AutoAccept": "",
    "AfterContactWorkTimeLimit": "",
    "DeskPhoneNumber": ""
  },
  "DirectoryUserId": "",
  "SecurityProfileIds": [],
  "RoutingProfileId": "",
  "HierarchyGroupId": "",
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/users/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/users/:InstanceId"

payload = {
    "Username": "",
    "Password": "",
    "IdentityInfo": {
        "FirstName": "",
        "LastName": "",
        "Email": "",
        "SecondaryEmail": "",
        "Mobile": ""
    },
    "PhoneConfig": {
        "PhoneType": "",
        "AutoAccept": "",
        "AfterContactWorkTimeLimit": "",
        "DeskPhoneNumber": ""
    },
    "DirectoryUserId": "",
    "SecurityProfileIds": [],
    "RoutingProfileId": "",
    "HierarchyGroupId": "",
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/users/:InstanceId"

payload <- "{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\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}}/users/:InstanceId")

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  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\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/users/:InstanceId') do |req|
  req.body = "{\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"IdentityInfo\": {\n    \"FirstName\": \"\",\n    \"LastName\": \"\",\n    \"Email\": \"\",\n    \"SecondaryEmail\": \"\",\n    \"Mobile\": \"\"\n  },\n  \"PhoneConfig\": {\n    \"PhoneType\": \"\",\n    \"AutoAccept\": \"\",\n    \"AfterContactWorkTimeLimit\": \"\",\n    \"DeskPhoneNumber\": \"\"\n  },\n  \"DirectoryUserId\": \"\",\n  \"SecurityProfileIds\": [],\n  \"RoutingProfileId\": \"\",\n  \"HierarchyGroupId\": \"\",\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}}/users/:InstanceId";

    let payload = json!({
        "Username": "",
        "Password": "",
        "IdentityInfo": json!({
            "FirstName": "",
            "LastName": "",
            "Email": "",
            "SecondaryEmail": "",
            "Mobile": ""
        }),
        "PhoneConfig": json!({
            "PhoneType": "",
            "AutoAccept": "",
            "AfterContactWorkTimeLimit": "",
            "DeskPhoneNumber": ""
        }),
        "DirectoryUserId": "",
        "SecurityProfileIds": (),
        "RoutingProfileId": "",
        "HierarchyGroupId": "",
        "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 '{
  "Username": "",
  "Password": "",
  "IdentityInfo": {
    "FirstName": "",
    "LastName": "",
    "Email": "",
    "SecondaryEmail": "",
    "Mobile": ""
  },
  "PhoneConfig": {
    "PhoneType": "",
    "AutoAccept": "",
    "AfterContactWorkTimeLimit": "",
    "DeskPhoneNumber": ""
  },
  "DirectoryUserId": "",
  "SecurityProfileIds": [],
  "RoutingProfileId": "",
  "HierarchyGroupId": "",
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/users/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Username": "",\n  "Password": "",\n  "IdentityInfo": {\n    "FirstName": "",\n    "LastName": "",\n    "Email": "",\n    "SecondaryEmail": "",\n    "Mobile": ""\n  },\n  "PhoneConfig": {\n    "PhoneType": "",\n    "AutoAccept": "",\n    "AfterContactWorkTimeLimit": "",\n    "DeskPhoneNumber": ""\n  },\n  "DirectoryUserId": "",\n  "SecurityProfileIds": [],\n  "RoutingProfileId": "",\n  "HierarchyGroupId": "",\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/users/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Username": "",
  "Password": "",
  "IdentityInfo": [
    "FirstName": "",
    "LastName": "",
    "Email": "",
    "SecondaryEmail": "",
    "Mobile": ""
  ],
  "PhoneConfig": [
    "PhoneType": "",
    "AutoAccept": "",
    "AfterContactWorkTimeLimit": "",
    "DeskPhoneNumber": ""
  ],
  "DirectoryUserId": "",
  "SecurityProfileIds": [],
  "RoutingProfileId": "",
  "HierarchyGroupId": "",
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:InstanceId")! 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}}/user-hierarchy-groups/:InstanceId");

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  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/user-hierarchy-groups/:InstanceId" {:content-type :json
                                                                             :form-params {:Name ""
                                                                                           :ParentGroupId ""
                                                                                           :Tags {}}})

require "http/client"

url = "{{baseUrl}}/user-hierarchy-groups/:InstanceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\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}}/user-hierarchy-groups/:InstanceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\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}}/user-hierarchy-groups/:InstanceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/user-hierarchy-groups/:InstanceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\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/user-hierarchy-groups/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "Name": "",
  "ParentGroupId": "",
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/user-hierarchy-groups/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user-hierarchy-groups/:InstanceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\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  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/user-hierarchy-groups/:InstanceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/user-hierarchy-groups/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  ParentGroupId: '',
  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}}/user-hierarchy-groups/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user-hierarchy-groups/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', ParentGroupId: '', Tags: {}}
};

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

const url = '{{baseUrl}}/user-hierarchy-groups/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","ParentGroupId":"","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}}/user-hierarchy-groups/:InstanceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "ParentGroupId": "",\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  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/user-hierarchy-groups/:InstanceId")
  .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/user-hierarchy-groups/:InstanceId',
  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({Name: '', ParentGroupId: '', Tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/user-hierarchy-groups/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {Name: '', ParentGroupId: '', 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}}/user-hierarchy-groups/:InstanceId');

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

req.type('json');
req.send({
  Name: '',
  ParentGroupId: '',
  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}}/user-hierarchy-groups/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', ParentGroupId: '', Tags: {}}
};

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

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

const url = '{{baseUrl}}/user-hierarchy-groups/:InstanceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","ParentGroupId":"","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 = @{ @"Name": @"",
                              @"ParentGroupId": @"",
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user-hierarchy-groups/:InstanceId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/user-hierarchy-groups/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/user-hierarchy-groups/:InstanceId",
  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([
    'Name' => '',
    'ParentGroupId' => '',
    '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}}/user-hierarchy-groups/:InstanceId', [
  'body' => '{
  "Name": "",
  "ParentGroupId": "",
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/user-hierarchy-groups/:InstanceId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'ParentGroupId' => '',
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'ParentGroupId' => '',
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/user-hierarchy-groups/:InstanceId');
$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}}/user-hierarchy-groups/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ParentGroupId": "",
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/user-hierarchy-groups/:InstanceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ParentGroupId": "",
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\n  \"Tags\": {}\n}"

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

conn.request("PUT", "/baseUrl/user-hierarchy-groups/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/user-hierarchy-groups/:InstanceId"

payload = {
    "Name": "",
    "ParentGroupId": "",
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/user-hierarchy-groups/:InstanceId"

payload <- "{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\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}}/user-hierarchy-groups/:InstanceId")

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  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\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/user-hierarchy-groups/:InstanceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"ParentGroupId\": \"\",\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}}/user-hierarchy-groups/:InstanceId";

    let payload = json!({
        "Name": "",
        "ParentGroupId": "",
        "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 '{
  "Name": "",
  "ParentGroupId": "",
  "Tags": {}
}' |  \
  http PUT {{baseUrl}}/user-hierarchy-groups/:InstanceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "ParentGroupId": "",\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/user-hierarchy-groups/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "ParentGroupId": "",
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user-hierarchy-groups/:InstanceId")! 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}}/vocabulary/:InstanceId");

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  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/vocabulary/:InstanceId" {:content-type :json
                                                                   :form-params {:ClientToken ""
                                                                                 :VocabularyName ""
                                                                                 :LanguageCode ""
                                                                                 :Content ""
                                                                                 :Tags {}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/vocabulary/:InstanceId"

	payload := strings.NewReader("{\n  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\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/vocabulary/:InstanceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 100

{
  "ClientToken": "",
  "VocabularyName": "",
  "LanguageCode": "",
  "Content": "",
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vocabulary/:InstanceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vocabulary/:InstanceId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\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  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vocabulary/:InstanceId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/vocabulary/:InstanceId")
  .header("content-type", "application/json")
  .body("{\n  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  ClientToken: '',
  VocabularyName: '',
  LanguageCode: '',
  Content: '',
  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}}/vocabulary/:InstanceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vocabulary/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {ClientToken: '', VocabularyName: '', LanguageCode: '', Content: '', Tags: {}}
};

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

const url = '{{baseUrl}}/vocabulary/:InstanceId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ClientToken":"","VocabularyName":"","LanguageCode":"","Content":"","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}}/vocabulary/:InstanceId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientToken": "",\n  "VocabularyName": "",\n  "LanguageCode": "",\n  "Content": "",\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  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vocabulary/:InstanceId")
  .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/vocabulary/:InstanceId',
  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({ClientToken: '', VocabularyName: '', LanguageCode: '', Content: '', Tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vocabulary/:InstanceId',
  headers: {'content-type': 'application/json'},
  body: {ClientToken: '', VocabularyName: '', LanguageCode: '', Content: '', 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}}/vocabulary/:InstanceId');

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

req.type('json');
req.send({
  ClientToken: '',
  VocabularyName: '',
  LanguageCode: '',
  Content: '',
  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}}/vocabulary/:InstanceId',
  headers: {'content-type': 'application/json'},
  data: {ClientToken: '', VocabularyName: '', LanguageCode: '', Content: '', Tags: {}}
};

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

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

const url = '{{baseUrl}}/vocabulary/:InstanceId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ClientToken":"","VocabularyName":"","LanguageCode":"","Content":"","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 = @{ @"ClientToken": @"",
                              @"VocabularyName": @"",
                              @"LanguageCode": @"",
                              @"Content": @"",
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vocabulary/:InstanceId"]
                                                       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}}/vocabulary/:InstanceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/vocabulary/:InstanceId",
  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([
    'ClientToken' => '',
    'VocabularyName' => '',
    'LanguageCode' => '',
    'Content' => '',
    '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}}/vocabulary/:InstanceId', [
  'body' => '{
  "ClientToken": "",
  "VocabularyName": "",
  "LanguageCode": "",
  "Content": "",
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientToken' => '',
  'VocabularyName' => '',
  'LanguageCode' => '',
  'Content' => '',
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'ClientToken' => '',
  'VocabularyName' => '',
  'LanguageCode' => '',
  'Content' => '',
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/vocabulary/:InstanceId');
$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}}/vocabulary/:InstanceId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "VocabularyName": "",
  "LanguageCode": "",
  "Content": "",
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vocabulary/:InstanceId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "VocabularyName": "",
  "LanguageCode": "",
  "Content": "",
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\n  \"Tags\": {}\n}"

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

conn.request("POST", "/baseUrl/vocabulary/:InstanceId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/vocabulary/:InstanceId"

payload = {
    "ClientToken": "",
    "VocabularyName": "",
    "LanguageCode": "",
    "Content": "",
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/vocabulary/:InstanceId"

payload <- "{\n  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\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}}/vocabulary/:InstanceId")

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  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\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/vocabulary/:InstanceId') do |req|
  req.body = "{\n  \"ClientToken\": \"\",\n  \"VocabularyName\": \"\",\n  \"LanguageCode\": \"\",\n  \"Content\": \"\",\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}}/vocabulary/:InstanceId";

    let payload = json!({
        "ClientToken": "",
        "VocabularyName": "",
        "LanguageCode": "",
        "Content": "",
        "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 '{
  "ClientToken": "",
  "VocabularyName": "",
  "LanguageCode": "",
  "Content": "",
  "Tags": {}
}' |  \
  http POST {{baseUrl}}/vocabulary/:InstanceId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientToken": "",\n  "VocabularyName": "",\n  "LanguageCode": "",\n  "Content": "",\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/vocabulary/:InstanceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ClientToken": "",
  "VocabularyName": "",
  "LanguageCode": "",
  "Content": "",
  "Tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vocabulary/:InstanceId")! 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}}/contact-flows/:InstanceId/:ContactFlowId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")

require "http/client"

url = "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"

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}}/contact-flows/:InstanceId/:ContactFlowId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"

	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/contact-flows/:InstanceId/:ContactFlowId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"))
    .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}}/contact-flows/:InstanceId/:ContactFlowId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")
  .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}}/contact-flows/:InstanceId/:ContactFlowId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId'
};

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

const url = '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId';
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}}/contact-flows/:InstanceId/:ContactFlowId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contact-flows/:InstanceId/:ContactFlowId',
  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}}/contact-flows/:InstanceId/:ContactFlowId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId');

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}}/contact-flows/:InstanceId/:ContactFlowId'
};

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

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

const url = '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId';
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}}/contact-flows/:InstanceId/:ContactFlowId"]
                                                       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}}/contact-flows/:InstanceId/:ContactFlowId" in

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

 "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId",
  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}}/contact-flows/:InstanceId/:ContactFlowId');

echo $response->getBody();

setUrl('{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/contact-flows/:InstanceId/:ContactFlowId")

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

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

import requests

url = "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")

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/contact-flows/:InstanceId/:ContactFlowId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId";

    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}}/contact-flows/:InstanceId/:ContactFlowId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")! 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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")

require "http/client"

url = "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"

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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"

	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/contact-flow-modules/:InstanceId/:ContactFlowModuleId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"))
    .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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")
  .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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId'
};

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

const url = '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId';
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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contact-flow-modules/:InstanceId/:ContactFlowModuleId',
  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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');

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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId'
};

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

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

const url = '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId';
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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"]
                                                       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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId" in

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

 "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId",
  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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');

echo $response->getBody();

setUrl('{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/contact-flow-modules/:InstanceId/:ContactFlowModuleId")

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

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

import requests

url = "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")

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/contact-flow-modules/:InstanceId/:ContactFlowModuleId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId";

    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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")! 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}}/hours-of-operations/:InstanceId/:HoursOfOperationId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")

require "http/client"

url = "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"

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}}/hours-of-operations/:InstanceId/:HoursOfOperationId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"

	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/hours-of-operations/:InstanceId/:HoursOfOperationId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"))
    .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}}/hours-of-operations/:InstanceId/:HoursOfOperationId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")
  .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}}/hours-of-operations/:InstanceId/:HoursOfOperationId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId'
};

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

const url = '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId';
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}}/hours-of-operations/:InstanceId/:HoursOfOperationId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/hours-of-operations/:InstanceId/:HoursOfOperationId',
  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}}/hours-of-operations/:InstanceId/:HoursOfOperationId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId');

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}}/hours-of-operations/:InstanceId/:HoursOfOperationId'
};

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

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

const url = '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId';
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}}/hours-of-operations/:InstanceId/:HoursOfOperationId"]
                                                       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}}/hours-of-operations/:InstanceId/:HoursOfOperationId" in

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

 "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId",
  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}}/hours-of-operations/:InstanceId/:HoursOfOperationId');

echo $response->getBody();

setUrl('{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/hours-of-operations/:InstanceId/:HoursOfOperationId")

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

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

import requests

url = "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")

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/hours-of-operations/:InstanceId/:HoursOfOperationId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId";

    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}}/hours-of-operations/:InstanceId/:HoursOfOperationId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")! 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}}/instance/:InstanceId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/instance/:InstanceId")

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId"

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}}/instance/:InstanceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId"

	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/instance/:InstanceId HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId"))
    .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}}/instance/:InstanceId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/instance/:InstanceId")
  .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}}/instance/:InstanceId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/instance/:InstanceId'};

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

const url = '{{baseUrl}}/instance/:InstanceId';
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}}/instance/:InstanceId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/instance/:InstanceId',
  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}}/instance/:InstanceId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/instance/:InstanceId');

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}}/instance/:InstanceId'};

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

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

const url = '{{baseUrl}}/instance/:InstanceId';
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}}/instance/:InstanceId"]
                                                       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}}/instance/:InstanceId" in

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

 "{{baseUrl}}/instance/:InstanceId",
  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}}/instance/:InstanceId');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/instance/:InstanceId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/instance/:InstanceId")

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId")

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/instance/:InstanceId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/instance/:InstanceId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId")! 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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId")

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId"

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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId"

	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/instance/:InstanceId/integration-associations/:IntegrationAssociationId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId"))
    .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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId")
  .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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId'
};

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

const url = '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId';
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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/instance/:InstanceId/integration-associations/:IntegrationAssociationId',
  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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId');

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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId'
};

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

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

const url = '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId';
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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId"]
                                                       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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId" in

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

 "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId",
  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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId');

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/instance/:InstanceId/integration-associations/:IntegrationAssociationId")

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

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

import requests

url = "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId")

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/instance/:InstanceId/integration-associations/:IntegrationAssociationId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId";

    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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId")! 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}}/quick-connects/:InstanceId/:QuickConnectId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")

require "http/client"

url = "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId"

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}}/quick-connects/:InstanceId/:QuickConnectId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId"

	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/quick-connects/:InstanceId/:QuickConnectId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId"))
    .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}}/quick-connects/:InstanceId/:QuickConnectId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")
  .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}}/quick-connects/:InstanceId/:QuickConnectId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId'
};

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

const url = '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId';
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}}/quick-connects/:InstanceId/:QuickConnectId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quick-connects/:InstanceId/:QuickConnectId',
  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}}/quick-connects/:InstanceId/:QuickConnectId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId');

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}}/quick-connects/:InstanceId/:QuickConnectId'
};

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

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

const url = '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId';
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}}/quick-connects/:InstanceId/:QuickConnectId"]
                                                       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}}/quick-connects/:InstanceId/:QuickConnectId" in

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

 "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId",
  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}}/quick-connects/:InstanceId/:QuickConnectId');

echo $response->getBody();

setUrl('{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/quick-connects/:InstanceId/:QuickConnectId")

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

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

import requests

url = "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")

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/quick-connects/:InstanceId/:QuickConnectId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId";

    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}}/quick-connects/:InstanceId/:QuickConnectId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")! 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}}/rules/:InstanceId/:RuleId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/rules/:InstanceId/:RuleId")

require "http/client"

url = "{{baseUrl}}/rules/:InstanceId/:RuleId"

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}}/rules/:InstanceId/:RuleId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/rules/:InstanceId/:RuleId"

	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/rules/:InstanceId/:RuleId HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rules/:InstanceId/:RuleId"))
    .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}}/rules/:InstanceId/:RuleId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/rules/:InstanceId/:RuleId")
  .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}}/rules/:InstanceId/:RuleId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/rules/:InstanceId/:RuleId'};

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

const url = '{{baseUrl}}/rules/:InstanceId/:RuleId';
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}}/rules/:InstanceId/:RuleId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rules/:InstanceId/:RuleId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rules/:InstanceId/:RuleId',
  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}}/rules/:InstanceId/:RuleId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/rules/:InstanceId/:RuleId');

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}}/rules/:InstanceId/:RuleId'};

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

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

const url = '{{baseUrl}}/rules/:InstanceId/:RuleId';
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}}/rules/:InstanceId/:RuleId"]
                                                       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}}/rules/:InstanceId/:RuleId" in

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

 "{{baseUrl}}/rules/:InstanceId/:RuleId",
  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}}/rules/:InstanceId/:RuleId');

echo $response->getBody();

setUrl('{{baseUrl}}/rules/:InstanceId/:RuleId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rules/:InstanceId/:RuleId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rules/:InstanceId/:RuleId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/rules/:InstanceId/:RuleId")

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

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

import requests

url = "{{baseUrl}}/rules/:InstanceId/:RuleId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rules/:InstanceId/:RuleId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rules/:InstanceId/:RuleId")

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/rules/:InstanceId/:RuleId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/rules/:InstanceId/:RuleId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/rules/:InstanceId/:RuleId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rules/:InstanceId/:RuleId")! 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}}/security-profiles/:InstanceId/:SecurityProfileId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId")

require "http/client"

url = "{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId"

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}}/security-profiles/:InstanceId/:SecurityProfileId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId"

	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/security-profiles/:InstanceId/:SecurityProfileId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId"))
    .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}}/security-profiles/:InstanceId/:SecurityProfileId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId")
  .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}}/security-profiles/:InstanceId/:SecurityProfileId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId'
};

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

const url = '{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId';
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}}/security-profiles/:InstanceId/:SecurityProfileId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/security-profiles/:InstanceId/:SecurityProfileId',
  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}}/security-profiles/:InstanceId/:SecurityProfileId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId');

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}}/security-profiles/:InstanceId/:SecurityProfileId'
};

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

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

const url = '{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId';
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}}/security-profiles/:InstanceId/:SecurityProfileId"]
                                                       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}}/security-profiles/:InstanceId/:SecurityProfileId" in

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

 "{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId",
  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}}/security-profiles/:InstanceId/:SecurityProfileId');

echo $response->getBody();

setUrl('{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/security-profiles/:InstanceId/:SecurityProfileId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId")

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/security-profiles/:InstanceId/:SecurityProfileId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId";

    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}}/security-profiles/:InstanceId/:SecurityProfileId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/security-profiles/:InstanceId/:SecurityProfileId")! 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}}/instance/:InstanceId/task/template/:TaskTemplateId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId")

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId"

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}}/instance/:InstanceId/task/template/:TaskTemplateId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId"

	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/instance/:InstanceId/task/template/:TaskTemplateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId"))
    .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}}/instance/:InstanceId/task/template/:TaskTemplateId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId")
  .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}}/instance/:InstanceId/task/template/:TaskTemplateId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId';
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}}/instance/:InstanceId/task/template/:TaskTemplateId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/instance/:InstanceId/task/template/:TaskTemplateId',
  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}}/instance/:InstanceId/task/template/:TaskTemplateId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId');

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}}/instance/:InstanceId/task/template/:TaskTemplateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId';
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}}/instance/:InstanceId/task/template/:TaskTemplateId"]
                                                       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}}/instance/:InstanceId/task/template/:TaskTemplateId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId",
  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}}/instance/:InstanceId/task/template/:TaskTemplateId');

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/instance/:InstanceId/task/template/:TaskTemplateId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId")

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/instance/:InstanceId/task/template/:TaskTemplateId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId";

    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}}/instance/:InstanceId/task/template/:TaskTemplateId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/task/template/:TaskTemplateId")! 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}}/traffic-distribution-group/:TrafficDistributionGroupId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId")

require "http/client"

url = "{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId"

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}}/traffic-distribution-group/:TrafficDistributionGroupId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId"

	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/traffic-distribution-group/:TrafficDistributionGroupId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId"))
    .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}}/traffic-distribution-group/:TrafficDistributionGroupId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId")
  .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}}/traffic-distribution-group/:TrafficDistributionGroupId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId';
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}}/traffic-distribution-group/:TrafficDistributionGroupId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/traffic-distribution-group/:TrafficDistributionGroupId',
  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}}/traffic-distribution-group/:TrafficDistributionGroupId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId');

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}}/traffic-distribution-group/:TrafficDistributionGroupId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId';
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}}/traffic-distribution-group/:TrafficDistributionGroupId"]
                                                       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}}/traffic-distribution-group/:TrafficDistributionGroupId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId",
  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}}/traffic-distribution-group/:TrafficDistributionGroupId');

echo $response->getBody();

setUrl('{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/traffic-distribution-group/:TrafficDistributionGroupId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId")

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/traffic-distribution-group/:TrafficDistributionGroupId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId";

    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}}/traffic-distribution-group/:TrafficDistributionGroupId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/traffic-distribution-group/:TrafficDistributionGroupId")! 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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId")

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId"

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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId"

	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/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId"))
    .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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId")
  .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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId';
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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId',
  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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId');

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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId';
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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId"]
                                                       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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId",
  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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId');

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId")

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/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId";

    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}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/integration-associations/:IntegrationAssociationId/use-cases/:UseCaseId")! 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}}/users/:InstanceId/:UserId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/users/:InstanceId/:UserId")

require "http/client"

url = "{{baseUrl}}/users/:InstanceId/:UserId"

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}}/users/:InstanceId/:UserId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/users/:InstanceId/:UserId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/users/:InstanceId/:UserId"

	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/users/:InstanceId/:UserId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/users/:InstanceId/:UserId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/users/:InstanceId/:UserId"))
    .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}}/users/:InstanceId/:UserId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/users/:InstanceId/:UserId")
  .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}}/users/:InstanceId/:UserId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/users/:InstanceId/:UserId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/users/:InstanceId/:UserId';
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}}/users/:InstanceId/:UserId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/users/:InstanceId/:UserId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/users/:InstanceId/:UserId',
  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}}/users/:InstanceId/:UserId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/users/:InstanceId/:UserId');

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}}/users/:InstanceId/:UserId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/users/:InstanceId/:UserId';
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}}/users/:InstanceId/:UserId"]
                                                       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}}/users/:InstanceId/:UserId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/users/:InstanceId/:UserId",
  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}}/users/:InstanceId/:UserId');

echo $response->getBody();

setUrl('{{baseUrl}}/users/:InstanceId/:UserId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/users/:InstanceId/:UserId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:InstanceId/:UserId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:InstanceId/:UserId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/users/:InstanceId/:UserId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/users/:InstanceId/:UserId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/users/:InstanceId/:UserId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/users/:InstanceId/:UserId")

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/users/:InstanceId/:UserId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/users/:InstanceId/:UserId";

    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}}/users/:InstanceId/:UserId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/users/:InstanceId/:UserId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:InstanceId/:UserId")! 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}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId")

require "http/client"

url = "{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId"

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}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId"

	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/user-hierarchy-groups/:InstanceId/:HierarchyGroupId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId';
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}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user-hierarchy-groups/:InstanceId/:HierarchyGroupId',
  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}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId';
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}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId"]
                                                       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}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId",
  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}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId');

echo $response->getBody();

setUrl('{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/user-hierarchy-groups/:InstanceId/:HierarchyGroupId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId")

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/user-hierarchy-groups/:InstanceId/:HierarchyGroupId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId";

    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}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user-hierarchy-groups/:InstanceId/:HierarchyGroupId")! 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}}/vocabulary-remove/:InstanceId/:VocabularyId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId")

require "http/client"

url = "{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/vocabulary-remove/:InstanceId/:VocabularyId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId';
const options = {method: 'POST'};

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}}/vocabulary-remove/:InstanceId/:VocabularyId',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vocabulary-remove/:InstanceId/:VocabularyId',
  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: 'POST',
  url: '{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId');

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}}/vocabulary-remove/:InstanceId/:VocabularyId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId';
const options = {method: 'POST'};

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}}/vocabulary-remove/:InstanceId/:VocabularyId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/vocabulary-remove/:InstanceId/:VocabularyId" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId');

echo $response->getBody();

setUrl('{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/vocabulary-remove/:InstanceId/:VocabularyId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/vocabulary-remove/:InstanceId/:VocabularyId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vocabulary-remove/:InstanceId/:VocabularyId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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}}/agent-status/:InstanceId/:AgentStatusId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId")

require "http/client"

url = "{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId"

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}}/agent-status/:InstanceId/:AgentStatusId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId"

	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/agent-status/:InstanceId/:AgentStatusId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId"))
    .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}}/agent-status/:InstanceId/:AgentStatusId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId")
  .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}}/agent-status/:InstanceId/:AgentStatusId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId';
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}}/agent-status/:InstanceId/:AgentStatusId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/agent-status/:InstanceId/:AgentStatusId',
  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}}/agent-status/:InstanceId/:AgentStatusId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId');

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}}/agent-status/:InstanceId/:AgentStatusId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId';
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}}/agent-status/:InstanceId/:AgentStatusId"]
                                                       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}}/agent-status/:InstanceId/:AgentStatusId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId",
  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}}/agent-status/:InstanceId/:AgentStatusId');

echo $response->getBody();

setUrl('{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/agent-status/:InstanceId/:AgentStatusId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId")

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/agent-status/:InstanceId/:AgentStatusId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/agent-status/:InstanceId/:AgentStatusId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/agent-status/:InstanceId/:AgentStatusId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/agent-status/:InstanceId/:AgentStatusId")! 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}}/contacts/:InstanceId/:ContactId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/contacts/:InstanceId/:ContactId")

require "http/client"

url = "{{baseUrl}}/contacts/:InstanceId/:ContactId"

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}}/contacts/:InstanceId/:ContactId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contacts/:InstanceId/:ContactId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contacts/:InstanceId/:ContactId"

	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/contacts/:InstanceId/:ContactId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contacts/:InstanceId/:ContactId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:InstanceId/:ContactId"))
    .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}}/contacts/:InstanceId/:ContactId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/contacts/:InstanceId/:ContactId")
  .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}}/contacts/:InstanceId/:ContactId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/contacts/:InstanceId/:ContactId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contacts/:InstanceId/:ContactId';
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}}/contacts/:InstanceId/:ContactId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:InstanceId/:ContactId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contacts/:InstanceId/:ContactId',
  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}}/contacts/:InstanceId/:ContactId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contacts/:InstanceId/:ContactId');

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}}/contacts/:InstanceId/:ContactId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contacts/:InstanceId/:ContactId';
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}}/contacts/:InstanceId/:ContactId"]
                                                       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}}/contacts/:InstanceId/:ContactId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contacts/:InstanceId/:ContactId",
  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}}/contacts/:InstanceId/:ContactId');

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:InstanceId/:ContactId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contacts/:InstanceId/:ContactId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:InstanceId/:ContactId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:InstanceId/:ContactId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/contacts/:InstanceId/:ContactId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contacts/:InstanceId/:ContactId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:InstanceId/:ContactId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:InstanceId/:ContactId")

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/contacts/:InstanceId/:ContactId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contacts/:InstanceId/:ContactId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/contacts/:InstanceId/:ContactId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/contacts/:InstanceId/:ContactId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts/:InstanceId/:ContactId")! 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}}/contact-flows/:InstanceId/:ContactFlowId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")

require "http/client"

url = "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"

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}}/contact-flows/:InstanceId/:ContactFlowId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"

	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/contact-flows/:InstanceId/:ContactFlowId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"))
    .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}}/contact-flows/:InstanceId/:ContactFlowId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")
  .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}}/contact-flows/:InstanceId/:ContactFlowId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId';
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}}/contact-flows/:InstanceId/:ContactFlowId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contact-flows/:InstanceId/:ContactFlowId',
  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}}/contact-flows/:InstanceId/:ContactFlowId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId');

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}}/contact-flows/:InstanceId/:ContactFlowId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId';
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}}/contact-flows/:InstanceId/:ContactFlowId"]
                                                       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}}/contact-flows/:InstanceId/:ContactFlowId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId",
  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}}/contact-flows/:InstanceId/:ContactFlowId');

echo $response->getBody();

setUrl('{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/contact-flows/:InstanceId/:ContactFlowId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")

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/contact-flows/:InstanceId/:ContactFlowId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact-flows/:InstanceId/:ContactFlowId")! 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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")

require "http/client"

url = "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"

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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"

	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/contact-flow-modules/:InstanceId/:ContactFlowModuleId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"))
    .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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")
  .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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId';
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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contact-flow-modules/:InstanceId/:ContactFlowModuleId',
  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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');

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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId';
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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"]
                                                       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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId",
  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}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');

echo $response->getBody();

setUrl('{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/contact-flow-modules/:InstanceId/:ContactFlowModuleId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")

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/contact-flow-modules/:InstanceId/:ContactFlowModuleId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact-flow-modules/:InstanceId/:ContactFlowModuleId")! 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}}/hours-of-operations/:InstanceId/:HoursOfOperationId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")

require "http/client"

url = "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"

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}}/hours-of-operations/:InstanceId/:HoursOfOperationId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"

	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/hours-of-operations/:InstanceId/:HoursOfOperationId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"))
    .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}}/hours-of-operations/:InstanceId/:HoursOfOperationId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")
  .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}}/hours-of-operations/:InstanceId/:HoursOfOperationId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId';
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}}/hours-of-operations/:InstanceId/:HoursOfOperationId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/hours-of-operations/:InstanceId/:HoursOfOperationId',
  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}}/hours-of-operations/:InstanceId/:HoursOfOperationId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId');

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}}/hours-of-operations/:InstanceId/:HoursOfOperationId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId';
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}}/hours-of-operations/:InstanceId/:HoursOfOperationId"]
                                                       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}}/hours-of-operations/:InstanceId/:HoursOfOperationId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId",
  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}}/hours-of-operations/:InstanceId/:HoursOfOperationId');

echo $response->getBody();

setUrl('{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/hours-of-operations/:InstanceId/:HoursOfOperationId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")

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/hours-of-operations/:InstanceId/:HoursOfOperationId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/hours-of-operations/:InstanceId/:HoursOfOperationId")! 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}}/instance/:InstanceId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/instance/:InstanceId")

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId"

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}}/instance/:InstanceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/instance/:InstanceId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/instance/:InstanceId"

	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/instance/:InstanceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/instance/:InstanceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId"))
    .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}}/instance/:InstanceId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/instance/:InstanceId")
  .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}}/instance/:InstanceId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/instance/:InstanceId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/instance/:InstanceId';
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}}/instance/:InstanceId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/instance/:InstanceId',
  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}}/instance/:InstanceId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/instance/:InstanceId');

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}}/instance/:InstanceId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/instance/:InstanceId';
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}}/instance/:InstanceId"]
                                                       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}}/instance/:InstanceId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/instance/:InstanceId",
  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}}/instance/:InstanceId');

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/instance/:InstanceId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/instance/:InstanceId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/instance/:InstanceId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/instance/:InstanceId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId")

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/instance/:InstanceId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/instance/:InstanceId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/instance/:InstanceId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId")! 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}}/instance/:InstanceId/attribute/:AttributeType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType")

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType"

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}}/instance/:InstanceId/attribute/:AttributeType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType"

	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/instance/:InstanceId/attribute/:AttributeType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType"))
    .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}}/instance/:InstanceId/attribute/:AttributeType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType")
  .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}}/instance/:InstanceId/attribute/:AttributeType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType';
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}}/instance/:InstanceId/attribute/:AttributeType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/instance/:InstanceId/attribute/:AttributeType',
  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}}/instance/:InstanceId/attribute/:AttributeType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType');

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}}/instance/:InstanceId/attribute/:AttributeType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType';
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}}/instance/:InstanceId/attribute/:AttributeType"]
                                                       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}}/instance/:InstanceId/attribute/:AttributeType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType",
  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}}/instance/:InstanceId/attribute/:AttributeType');

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/instance/:InstanceId/attribute/:AttributeType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType")

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/instance/:InstanceId/attribute/:AttributeType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/instance/:InstanceId/attribute/:AttributeType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/instance/:InstanceId/attribute/:AttributeType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/attribute/:AttributeType")! 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}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId#resourceType" {:query-params {:resourceType ""}})

require "http/client"

url = "{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType"

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}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType"

	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/instance/:InstanceId/storage-config/:AssociationId?resourceType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType"))
    .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}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType")
  .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}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType';
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}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/instance/:InstanceId/storage-config/:AssociationId?resourceType=',
  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}}/instance/:InstanceId/storage-config/:AssociationId#resourceType',
  qs: {resourceType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId#resourceType');

req.query({
  resourceType: ''
});

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}}/instance/:InstanceId/storage-config/:AssociationId#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType';
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}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType"]
                                                       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}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType",
  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}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId#resourceType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resourceType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId#resourceType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resourceType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/instance/:InstanceId/storage-config/:AssociationId?resourceType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId#resourceType"

querystring = {"resourceType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId#resourceType"

queryString <- list(resourceType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType")

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/instance/:InstanceId/storage-config/:AssociationId') do |req|
  req.params['resourceType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId#resourceType";

    let querystring = [
        ("resourceType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/instance/:InstanceId/storage-config/:AssociationId?resourceType=#resourceType")! 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}}/phone-number/:PhoneNumberId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/phone-number/:PhoneNumberId")

require "http/client"

url = "{{baseUrl}}/phone-number/:PhoneNumberId"

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}}/phone-number/:PhoneNumberId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/phone-number/:PhoneNumberId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/phone-number/:PhoneNumberId"

	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/phone-number/:PhoneNumberId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/phone-number/:PhoneNumberId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/phone-number/:PhoneNumberId"))
    .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}}/phone-number/:PhoneNumberId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/phone-number/:PhoneNumberId")
  .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}}/phone-number/:PhoneNumberId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/phone-number/:PhoneNumberId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/phone-number/:PhoneNumberId';
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}}/phone-number/:PhoneNumberId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/phone-number/:PhoneNumberId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/phone-number/:PhoneNumberId',
  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}}/phone-number/:PhoneNumberId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/phone-number/:PhoneNumberId');

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}}/phone-number/:PhoneNumberId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/phone-number/:PhoneNumberId';
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}}/phone-number/:PhoneNumberId"]
                                                       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}}/phone-number/:PhoneNumberId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/phone-number/:PhoneNumberId",
  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}}/phone-number/:PhoneNumberId');

echo $response->getBody();

setUrl('{{baseUrl}}/phone-number/:PhoneNumberId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/phone-number/:PhoneNumberId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/phone-number/:PhoneNumberId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/phone-number/:PhoneNumberId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/phone-number/:PhoneNumberId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/phone-number/:PhoneNumberId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/phone-number/:PhoneNumberId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/phone-number/:PhoneNumberId")

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/phone-number/:PhoneNumberId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/phone-number/:PhoneNumberId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/phone-number/:PhoneNumberId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/phone-number/:PhoneNumberId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/phone-number/:PhoneNumberId")! 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}}/queues/:InstanceId/:QueueId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/queues/:InstanceId/:QueueId")

require "http/client"

url = "{{baseUrl}}/queues/:InstanceId/:QueueId"

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}}/queues/:InstanceId/:QueueId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/queues/:InstanceId/:QueueId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/queues/:InstanceId/:QueueId"

	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/queues/:InstanceId/:QueueId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/queues/:InstanceId/:QueueId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/queues/:InstanceId/:QueueId"))
    .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}}/queues/:InstanceId/:QueueId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/queues/:InstanceId/:QueueId")
  .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}}/queues/:InstanceId/:QueueId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/queues/:InstanceId/:QueueId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/queues/:InstanceId/:QueueId';
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}}/queues/:InstanceId/:QueueId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/queues/:InstanceId/:QueueId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/queues/:InstanceId/:QueueId',
  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}}/queues/:InstanceId/:QueueId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/queues/:InstanceId/:QueueId');

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}}/queues/:InstanceId/:QueueId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/queues/:InstanceId/:QueueId';
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}}/queues/:InstanceId/:QueueId"]
                                                       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}}/queues/:InstanceId/:QueueId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/queues/:InstanceId/:QueueId",
  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}}/queues/:InstanceId/:QueueId');

echo $response->getBody();

setUrl('{{baseUrl}}/queues/:InstanceId/:QueueId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/queues/:InstanceId/:QueueId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/queues/:InstanceId/:QueueId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/queues/:InstanceId/:QueueId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/queues/:InstanceId/:QueueId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/queues/:InstanceId/:QueueId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/queues/:InstanceId/:QueueId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/queues/:InstanceId/:QueueId")

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/queues/:InstanceId/:QueueId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/queues/:InstanceId/:QueueId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/queues/:InstanceId/:QueueId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/queues/:InstanceId/:QueueId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/queues/:InstanceId/:QueueId")! 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}}/quick-connects/:InstanceId/:QuickConnectId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")

require "http/client"

url = "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId"

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}}/quick-connects/:InstanceId/:QuickConnectId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId"

	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/quick-connects/:InstanceId/:QuickConnectId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId"))
    .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}}/quick-connects/:InstanceId/:QuickConnectId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")
  .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}}/quick-connects/:InstanceId/:QuickConnectId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId';
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}}/quick-connects/:InstanceId/:QuickConnectId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quick-connects/:InstanceId/:QuickConnectId',
  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}}/quick-connects/:InstanceId/:QuickConnectId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId');

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}}/quick-connects/:InstanceId/:QuickConnectId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quick-connects/:InstanceId/:QuickConnectId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}