Amazon Chimev2018-05-01

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:accountId/users/:userId#operation=associate-phone-number" {:query-params {:operation ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:E164PhoneNumber ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"E164PhoneNumber\": \"\"\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}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number"),
    Content = new StringContent("{\n  \"E164PhoneNumber\": \"\"\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}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"E164PhoneNumber\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number"

	payload := strings.NewReader("{\n  \"E164PhoneNumber\": \"\"\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/accounts/:accountId/users/:userId?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 27

{
  "E164PhoneNumber": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"E164PhoneNumber\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"E164PhoneNumber\": \"\"\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  \"E164PhoneNumber\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number")
  .header("content-type", "application/json")
  .body("{\n  \"E164PhoneNumber\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users/:userId#operation=associate-phone-number',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {E164PhoneNumber: ''}
};

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

const url = '{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"E164PhoneNumber":""}'
};

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}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "E164PhoneNumber": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"E164PhoneNumber\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number")
  .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/accounts/:accountId/users/:userId?operation=',
  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({E164PhoneNumber: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users/:userId#operation=associate-phone-number',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {E164PhoneNumber: ''},
  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}}/accounts/:accountId/users/:userId#operation=associate-phone-number');

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

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

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

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}}/accounts/:accountId/users/:userId#operation=associate-phone-number',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {E164PhoneNumber: ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"E164PhoneNumber":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number"]
                                                       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}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"E164PhoneNumber\": \"\"\n}" in

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

 "{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number",
  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([
    'E164PhoneNumber' => ''
  ]),
  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}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number', [
  'body' => '{
  "E164PhoneNumber": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/users/:userId#operation=associate-phone-number');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

append(json_encode([
  'E164PhoneNumber' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId/users/:userId#operation=associate-phone-number');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "E164PhoneNumber": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "E164PhoneNumber": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/accounts/:accountId/users/:userId?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/users/:userId#operation=associate-phone-number"

querystring = {"operation":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/users/:userId#operation=associate-phone-number"

queryString <- list(operation = "")

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

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number")

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  \"E164PhoneNumber\": \"\"\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/accounts/:accountId/users/:userId') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"E164PhoneNumber\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/users/:userId#operation=associate-phone-number";

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

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

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

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

    dbg!(results);
}

echo '{
  "E164PhoneNumber": ""
}' |  \
  http POST '{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "E164PhoneNumber": ""\n}' \
  --output-document \
  - '{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/users/:userId?operation=#operation=associate-phone-number")! 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}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers");

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  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers" {:query-params {:operation ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:E164PhoneNumbers []
                                                                                                                               :ForceAssociate false}})

require "http/client"

url = "{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\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}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers"),
    Content = new StringContent("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": 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}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers"

	payload := strings.NewReader("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\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/voice-connectors/:voiceConnectorId?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": 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  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers")
  .header("content-type", "application/json")
  .body("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}")
  .asString();

const data = JSON.stringify({
  E164PhoneNumbers: [],
  ForceAssociate: false
});

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

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

xhr.open('POST', '{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {E164PhoneNumbers: [], ForceAssociate: false}
};

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

const url = '{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"E164PhoneNumbers":[],"ForceAssociate":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}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "E164PhoneNumbers": [],\n  "ForceAssociate": 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  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers")
  .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/voice-connectors/:voiceConnectorId?operation=',
  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({E164PhoneNumbers: [], ForceAssociate: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {E164PhoneNumbers: [], ForceAssociate: 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('POST', '{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers');

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

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

req.type('json');
req.send({
  E164PhoneNumbers: [],
  ForceAssociate: 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: 'POST',
  url: '{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {E164PhoneNumbers: [], ForceAssociate: false}
};

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

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

const url = '{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"E164PhoneNumbers":[],"ForceAssociate":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 = @{ @"E164PhoneNumbers": @[  ],
                              @"ForceAssociate": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers"]
                                                       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}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}" in

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

 "{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers",
  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([
    'E164PhoneNumbers' => [
        
    ],
    'ForceAssociate' => 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('POST', '{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers', [
  'body' => '{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers');
$request->setMethod(HTTP_METH_POST);

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'E164PhoneNumbers' => [
    
  ],
  'ForceAssociate' => null
]));

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

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

append(json_encode([
  'E164PhoneNumbers' => [
    
  ],
  'ForceAssociate' => null
]));
$request->setRequestUrl('{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}'

import http.client

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

payload = "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}"

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

conn.request("POST", "/baseUrl/voice-connectors/:voiceConnectorId?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers"

querystring = {"operation":""}

payload = {
    "E164PhoneNumbers": [],
    "ForceAssociate": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers"

queryString <- list(operation = "")

payload <- "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers")

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  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": 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.post('/baseUrl/voice-connectors/:voiceConnectorId') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/voice-connectors/:voiceConnectorId#operation=associate-phone-numbers";

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

    let payload = json!({
        "E164PhoneNumbers": (),
        "ForceAssociate": false
    });

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

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

    dbg!(results);
}

echo '{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}' |  \
  http POST '{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "E164PhoneNumbers": [],\n  "ForceAssociate": false\n}' \
  --output-document \
  - '{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "E164PhoneNumbers": [],
  "ForceAssociate": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/voice-connectors/:voiceConnectorId?operation=#operation=associate-phone-numbers")! 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}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers");

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  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers" {:query-params {:operation ""}
                                                                                                                            :content-type :json
                                                                                                                            :form-params {:E164PhoneNumbers []
                                                                                                                                          :ForceAssociate false}})

require "http/client"

url = "{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\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}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers"),
    Content = new StringContent("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": 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}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers"

	payload := strings.NewReader("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\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/voice-connector-groups/:voiceConnectorGroupId?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": 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  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers")
  .header("content-type", "application/json")
  .body("{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}")
  .asString();

const data = JSON.stringify({
  E164PhoneNumbers: [],
  ForceAssociate: false
});

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

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

xhr.open('POST', '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {E164PhoneNumbers: [], ForceAssociate: false}
};

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

const url = '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"E164PhoneNumbers":[],"ForceAssociate":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}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "E164PhoneNumbers": [],\n  "ForceAssociate": 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  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers")
  .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/voice-connector-groups/:voiceConnectorGroupId?operation=',
  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({E164PhoneNumbers: [], ForceAssociate: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {E164PhoneNumbers: [], ForceAssociate: 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('POST', '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers');

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

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

req.type('json');
req.send({
  E164PhoneNumbers: [],
  ForceAssociate: 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: 'POST',
  url: '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {E164PhoneNumbers: [], ForceAssociate: false}
};

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

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

const url = '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"E164PhoneNumbers":[],"ForceAssociate":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 = @{ @"E164PhoneNumbers": @[  ],
                              @"ForceAssociate": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers"]
                                                       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}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}" in

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

 "{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers",
  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([
    'E164PhoneNumbers' => [
        
    ],
    'ForceAssociate' => 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('POST', '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers', [
  'body' => '{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers');
$request->setMethod(HTTP_METH_POST);

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'E164PhoneNumbers' => [
    
  ],
  'ForceAssociate' => null
]));

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

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

append(json_encode([
  'E164PhoneNumbers' => [
    
  ],
  'ForceAssociate' => null
]));
$request->setRequestUrl('{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}'

import http.client

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

payload = "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}"

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

conn.request("POST", "/baseUrl/voice-connector-groups/:voiceConnectorGroupId?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers"

querystring = {"operation":""}

payload = {
    "E164PhoneNumbers": [],
    "ForceAssociate": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers"

queryString <- list(operation = "")

payload <- "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers")

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  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": 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.post('/baseUrl/voice-connector-groups/:voiceConnectorGroupId') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"E164PhoneNumbers\": [],\n  \"ForceAssociate\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId#operation=associate-phone-numbers";

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

    let payload = json!({
        "E164PhoneNumbers": (),
        "ForceAssociate": false
    });

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

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

    dbg!(results);
}

echo '{
  "E164PhoneNumbers": [],
  "ForceAssociate": false
}' |  \
  http POST '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "E164PhoneNumbers": [],\n  "ForceAssociate": false\n}' \
  --output-document \
  - '{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "E164PhoneNumbers": [],
  "ForceAssociate": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/voice-connector-groups/:voiceConnectorGroupId?operation=#operation=associate-phone-numbers")! 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}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:accountId#operation=associate-signin-delegate-groups" {:query-params {:operation ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:SigninDelegateGroups [{:GroupName ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\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}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups"),
    Content = new StringContent("{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\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}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups"

	payload := strings.NewReader("{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\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/accounts/:accountId?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "SigninDelegateGroups": [
    {
      "GroupName": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\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  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups")
  .header("content-type", "application/json")
  .body("{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  SigninDelegateGroups: [
    {
      GroupName: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId#operation=associate-signin-delegate-groups',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {SigninDelegateGroups: [{GroupName: ''}]}
};

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

const url = '{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SigninDelegateGroups":[{"GroupName":""}]}'
};

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}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SigninDelegateGroups": [\n    {\n      "GroupName": ""\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  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups")
  .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/accounts/:accountId?operation=',
  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({SigninDelegateGroups: [{GroupName: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId#operation=associate-signin-delegate-groups',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {SigninDelegateGroups: [{GroupName: ''}]},
  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}}/accounts/:accountId#operation=associate-signin-delegate-groups');

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

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

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

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}}/accounts/:accountId#operation=associate-signin-delegate-groups',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {SigninDelegateGroups: [{GroupName: ''}]}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SigninDelegateGroups":[{"GroupName":""}]}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups"]
                                                       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}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups",
  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([
    'SigninDelegateGroups' => [
        [
                'GroupName' => ''
        ]
    ]
  ]),
  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}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups', [
  'body' => '{
  "SigninDelegateGroups": [
    {
      "GroupName": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId#operation=associate-signin-delegate-groups');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

append(json_encode([
  'SigninDelegateGroups' => [
    [
        'GroupName' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId#operation=associate-signin-delegate-groups');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SigninDelegateGroups": [
    {
      "GroupName": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SigninDelegateGroups": [
    {
      "GroupName": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/accounts/:accountId?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId#operation=associate-signin-delegate-groups"

querystring = {"operation":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId#operation=associate-signin-delegate-groups"

queryString <- list(operation = "")

payload <- "{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups")

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  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\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/accounts/:accountId') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"SigninDelegateGroups\": [\n    {\n      \"GroupName\": \"\"\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}}/accounts/:accountId#operation=associate-signin-delegate-groups";

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

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

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

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

    dbg!(results);
}

echo '{
  "SigninDelegateGroups": [
    {
      "GroupName": ""
    }
  ]
}' |  \
  http POST '{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "SigninDelegateGroups": [\n    {\n      "GroupName": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId?operation=#operation=associate-signin-delegate-groups")! 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}}/meetings/:meetingId/attendees?operation=#operation=batch-create");

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  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/meetings/:meetingId/attendees#operation=batch-create" {:query-params {:operation ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:Attendees [{:ExternalUserId ""
                                                                                                                            :Tags ""}]}})

require "http/client"

url = "{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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}}/meetings/:meetingId/attendees?operation=#operation=batch-create"),
    Content = new StringContent("{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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}}/meetings/:meetingId/attendees?operation=#operation=batch-create");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create"

	payload := strings.NewReader("{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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/meetings/:meetingId/attendees?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create")
  .header("content-type", "application/json")
  .body("{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Attendees: [
    {
      ExternalUserId: '',
      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}}/meetings/:meetingId/attendees?operation=#operation=batch-create');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings/:meetingId/attendees#operation=batch-create',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {Attendees: [{ExternalUserId: '', Tags: ''}]}
};

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

const url = '{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Attendees":[{"ExternalUserId":"","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}}/meetings/:meetingId/attendees?operation=#operation=batch-create',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Attendees": [\n    {\n      "ExternalUserId": "",\n      "Tags": ""\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  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create")
  .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/meetings/:meetingId/attendees?operation=',
  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({Attendees: [{ExternalUserId: '', Tags: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings/:meetingId/attendees#operation=batch-create',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {Attendees: [{ExternalUserId: '', 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}}/meetings/:meetingId/attendees#operation=batch-create');

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

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

req.type('json');
req.send({
  Attendees: [
    {
      ExternalUserId: '',
      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}}/meetings/:meetingId/attendees#operation=batch-create',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {Attendees: [{ExternalUserId: '', Tags: ''}]}
};

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

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

const url = '{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Attendees":[{"ExternalUserId":"","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 = @{ @"Attendees": @[ @{ @"ExternalUserId": @"", @"Tags": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create"]
                                                       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}}/meetings/:meetingId/attendees?operation=#operation=batch-create" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create",
  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([
    'Attendees' => [
        [
                'ExternalUserId' => '',
                '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}}/meetings/:meetingId/attendees?operation=#operation=batch-create', [
  'body' => '{
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/meetings/:meetingId/attendees#operation=batch-create');
$request->setMethod(HTTP_METH_POST);

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Attendees' => [
    [
        'ExternalUserId' => '',
        'Tags' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Attendees' => [
    [
        'ExternalUserId' => '',
        'Tags' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/meetings/:meetingId/attendees#operation=batch-create');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/meetings/:meetingId/attendees?operation=#operation=batch-create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/meetings/:meetingId/attendees?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/meetings/:meetingId/attendees#operation=batch-create"

querystring = {"operation":""}

payload = { "Attendees": [
        {
            "ExternalUserId": "",
            "Tags": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/meetings/:meetingId/attendees#operation=batch-create"

queryString <- list(operation = "")

payload <- "{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create")

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  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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/meetings/:meetingId/attendees') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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}}/meetings/:meetingId/attendees#operation=batch-create";

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

    let payload = json!({"Attendees": (
            json!({
                "ExternalUserId": "",
                "Tags": ""
            })
        )});

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

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

    dbg!(results);
}

echo '{
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}' |  \
  http POST '{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Attendees": [\n    {\n      "ExternalUserId": "",\n      "Tags": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Attendees": [
    [
      "ExternalUserId": "",
      "Tags": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/meetings/:meetingId/attendees?operation=#operation=batch-create")! 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}}/channels/:channelArn/memberships?operation=#operation=batch-create");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/channels/:channelArn/memberships#operation=batch-create" {:query-params {:operation ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Type ""
                                                                                                                  :MemberArns []}})

require "http/client"

url = "{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Type\": \"\",\n  \"MemberArns\": []\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}}/channels/:channelArn/memberships?operation=#operation=batch-create"),
    Content = new StringContent("{\n  \"Type\": \"\",\n  \"MemberArns\": []\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}}/channels/:channelArn/memberships?operation=#operation=batch-create");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Type\": \"\",\n  \"MemberArns\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create"

	payload := strings.NewReader("{\n  \"Type\": \"\",\n  \"MemberArns\": []\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/channels/:channelArn/memberships?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "Type": "",
  "MemberArns": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Type\": \"\",\n  \"MemberArns\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Type\": \"\",\n  \"MemberArns\": []\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  \"Type\": \"\",\n  \"MemberArns\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create")
  .header("content-type", "application/json")
  .body("{\n  \"Type\": \"\",\n  \"MemberArns\": []\n}")
  .asString();

const data = JSON.stringify({
  Type: '',
  MemberArns: []
});

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

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

xhr.open('POST', '{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels/:channelArn/memberships#operation=batch-create',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {Type: '', MemberArns: []}
};

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

const url = '{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Type":"","MemberArns":[]}'
};

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}}/channels/:channelArn/memberships?operation=#operation=batch-create',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Type": "",\n  "MemberArns": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Type\": \"\",\n  \"MemberArns\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create")
  .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/channels/:channelArn/memberships?operation=',
  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({Type: '', MemberArns: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels/:channelArn/memberships#operation=batch-create',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {Type: '', MemberArns: []},
  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}}/channels/:channelArn/memberships#operation=batch-create');

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

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

req.type('json');
req.send({
  Type: '',
  MemberArns: []
});

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}}/channels/:channelArn/memberships#operation=batch-create',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {Type: '', MemberArns: []}
};

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

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

const url = '{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Type":"","MemberArns":[]}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create"]
                                                       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}}/channels/:channelArn/memberships?operation=#operation=batch-create" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Type\": \"\",\n  \"MemberArns\": []\n}" in

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

 "{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create",
  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([
    'Type' => '',
    'MemberArns' => [
        
    ]
  ]),
  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}}/channels/:channelArn/memberships?operation=#operation=batch-create', [
  'body' => '{
  "Type": "",
  "MemberArns": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channelArn/memberships#operation=batch-create');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

append(json_encode([
  'Type' => '',
  'MemberArns' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/channels/:channelArn/memberships#operation=batch-create');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/channels/:channelArn/memberships?operation=#operation=batch-create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Type": "",
  "MemberArns": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Type": "",
  "MemberArns": []
}'

import http.client

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

payload = "{\n  \"Type\": \"\",\n  \"MemberArns\": []\n}"

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

conn.request("POST", "/baseUrl/channels/:channelArn/memberships?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/channels/:channelArn/memberships#operation=batch-create"

querystring = {"operation":""}

payload = {
    "Type": "",
    "MemberArns": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channelArn/memberships#operation=batch-create"

queryString <- list(operation = "")

payload <- "{\n  \"Type\": \"\",\n  \"MemberArns\": []\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create")

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  \"Type\": \"\",\n  \"MemberArns\": []\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/channels/:channelArn/memberships') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"Type\": \"\",\n  \"MemberArns\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channelArn/memberships#operation=batch-create";

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

    let payload = json!({
        "Type": "",
        "MemberArns": ()
    });

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

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

    dbg!(results);
}

echo '{
  "Type": "",
  "MemberArns": []
}' |  \
  http POST '{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Type": "",\n  "MemberArns": []\n}' \
  --output-document \
  - '{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channelArn/memberships?operation=#operation=batch-create")! 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}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create");

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  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create" {:query-params {:operation ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:MembershipItemList [{:MemberId ""
                                                                                                                                                     :Role ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\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}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create"),
    Content = new StringContent("{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\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}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create"

	payload := strings.NewReader("{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\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/accounts/:accountId/rooms/:roomId/memberships?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "MembershipItemList": [
    {
      "MemberId": "",
      "Role": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\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  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create")
  .header("content-type", "application/json")
  .body("{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  MembershipItemList: [
    {
      MemberId: '',
      Role: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {MembershipItemList: [{MemberId: '', Role: ''}]}
};

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

const url = '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MembershipItemList":[{"MemberId":"","Role":""}]}'
};

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}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MembershipItemList": [\n    {\n      "MemberId": "",\n      "Role": ""\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  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create")
  .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/accounts/:accountId/rooms/:roomId/memberships?operation=',
  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({MembershipItemList: [{MemberId: '', Role: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {MembershipItemList: [{MemberId: '', Role: ''}]},
  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}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create');

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

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

req.type('json');
req.send({
  MembershipItemList: [
    {
      MemberId: '',
      Role: ''
    }
  ]
});

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}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {MembershipItemList: [{MemberId: '', Role: ''}]}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MembershipItemList":[{"MemberId":"","Role":""}]}'
};

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 = @{ @"MembershipItemList": @[ @{ @"MemberId": @"", @"Role": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create"]
                                                       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}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create",
  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([
    'MembershipItemList' => [
        [
                'MemberId' => '',
                'Role' => ''
        ]
    ]
  ]),
  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}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create', [
  'body' => '{
  "MembershipItemList": [
    {
      "MemberId": "",
      "Role": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create');
$request->setMethod(HTTP_METH_POST);

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MembershipItemList' => [
    [
        'MemberId' => '',
        'Role' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'MembershipItemList' => [
    [
        'MemberId' => '',
        'Role' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MembershipItemList": [
    {
      "MemberId": "",
      "Role": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MembershipItemList": [
    {
      "MemberId": "",
      "Role": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/accounts/:accountId/rooms/:roomId/memberships?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create"

querystring = {"operation":""}

payload = { "MembershipItemList": [
        {
            "MemberId": "",
            "Role": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create"

queryString <- list(operation = "")

payload <- "{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create")

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  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\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/accounts/:accountId/rooms/:roomId/memberships') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"MembershipItemList\": [\n    {\n      \"MemberId\": \"\",\n      \"Role\": \"\"\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}}/accounts/:accountId/rooms/:roomId/memberships#operation=batch-create";

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

    let payload = json!({"MembershipItemList": (
            json!({
                "MemberId": "",
                "Role": ""
            })
        )});

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

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

    dbg!(results);
}

echo '{
  "MembershipItemList": [
    {
      "MemberId": "",
      "Role": ""
    }
  ]
}' |  \
  http POST '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "MembershipItemList": [\n    {\n      "MemberId": "",\n      "Role": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["MembershipItemList": [
    [
      "MemberId": "",
      "Role": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships?operation=#operation=batch-create")! 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}}/phone-numbers?operation=#operation=batch-delete");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"PhoneNumberIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/phone-numbers#operation=batch-delete" {:query-params {:operation ""}
                                                                                 :content-type :json
                                                                                 :form-params {:PhoneNumberIds []}})

require "http/client"

url = "{{baseUrl}}/phone-numbers?operation=#operation=batch-delete"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"PhoneNumberIds\": []\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-numbers?operation=#operation=batch-delete"),
    Content = new StringContent("{\n  \"PhoneNumberIds\": []\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-numbers?operation=#operation=batch-delete");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PhoneNumberIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/phone-numbers?operation=#operation=batch-delete"

	payload := strings.NewReader("{\n  \"PhoneNumberIds\": []\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-numbers?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 26

{
  "PhoneNumberIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/phone-numbers?operation=#operation=batch-delete")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PhoneNumberIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/phone-numbers?operation=#operation=batch-delete"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PhoneNumberIds\": []\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  \"PhoneNumberIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/phone-numbers?operation=#operation=batch-delete")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/phone-numbers?operation=#operation=batch-delete")
  .header("content-type", "application/json")
  .body("{\n  \"PhoneNumberIds\": []\n}")
  .asString();

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

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-numbers?operation=#operation=batch-delete');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/phone-numbers#operation=batch-delete',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {PhoneNumberIds: []}
};

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

const url = '{{baseUrl}}/phone-numbers?operation=#operation=batch-delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PhoneNumberIds":[]}'
};

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-numbers?operation=#operation=batch-delete',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PhoneNumberIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PhoneNumberIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/phone-numbers?operation=#operation=batch-delete")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/phone-numbers?operation=',
  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({PhoneNumberIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/phone-numbers#operation=batch-delete',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {PhoneNumberIds: []},
  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-numbers#operation=batch-delete');

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

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

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

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-numbers#operation=batch-delete',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {PhoneNumberIds: []}
};

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

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

const url = '{{baseUrl}}/phone-numbers?operation=#operation=batch-delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PhoneNumberIds":[]}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/phone-numbers?operation=#operation=batch-delete"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/phone-numbers?operation=#operation=batch-delete" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"PhoneNumberIds\": []\n}" in

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

 "{{baseUrl}}/phone-numbers?operation=#operation=batch-delete",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'PhoneNumberIds' => [
        
    ]
  ]),
  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-numbers?operation=#operation=batch-delete', [
  'body' => '{
  "PhoneNumberIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/phone-numbers#operation=batch-delete');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

append(json_encode([
  'PhoneNumberIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/phone-numbers#operation=batch-delete');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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-numbers?operation=#operation=batch-delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PhoneNumberIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/phone-numbers?operation=#operation=batch-delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PhoneNumberIds": []
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/phone-numbers?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/phone-numbers#operation=batch-delete"

querystring = {"operation":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/phone-numbers#operation=batch-delete"

queryString <- list(operation = "")

payload <- "{\n  \"PhoneNumberIds\": []\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/phone-numbers?operation=#operation=batch-delete")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"PhoneNumberIds\": []\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-numbers') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"PhoneNumberIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/phone-numbers#operation=batch-delete";

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

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

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

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

    dbg!(results);
}

echo '{
  "PhoneNumberIds": []
}' |  \
  http POST '{{baseUrl}}/phone-numbers?operation=#operation=batch-delete' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "PhoneNumberIds": []\n}' \
  --output-document \
  - '{{baseUrl}}/phone-numbers?operation=#operation=batch-delete'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/phone-numbers?operation=#operation=batch-delete")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:accountId/users#operation=suspend" {:query-params {:operation ""}
                                                                                        :content-type :json
                                                                                        :form-params {:UserIdList []}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserIdList\": []\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}}/accounts/:accountId/users?operation=#operation=suspend"),
    Content = new StringContent("{\n  \"UserIdList\": []\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}}/accounts/:accountId/users?operation=#operation=suspend");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserIdList\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend"

	payload := strings.NewReader("{\n  \"UserIdList\": []\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/accounts/:accountId/users?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "UserIdList": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserIdList\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserIdList\": []\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  \"UserIdList\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend")
  .header("content-type", "application/json")
  .body("{\n  \"UserIdList\": []\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users#operation=suspend',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {UserIdList: []}
};

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

const url = '{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"UserIdList":[]}'
};

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}}/accounts/:accountId/users?operation=#operation=suspend',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserIdList": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserIdList\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend")
  .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/accounts/:accountId/users?operation=',
  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({UserIdList: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users#operation=suspend',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {UserIdList: []},
  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}}/accounts/:accountId/users#operation=suspend');

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

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

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

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}}/accounts/:accountId/users#operation=suspend',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {UserIdList: []}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"UserIdList":[]}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend"]
                                                       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}}/accounts/:accountId/users?operation=#operation=suspend" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"UserIdList\": []\n}" in

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

 "{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend",
  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([
    'UserIdList' => [
        
    ]
  ]),
  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}}/accounts/:accountId/users?operation=#operation=suspend', [
  'body' => '{
  "UserIdList": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/users#operation=suspend');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

append(json_encode([
  'UserIdList' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId/users#operation=suspend');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/accounts/:accountId/users?operation=#operation=suspend' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserIdList": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserIdList": []
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/accounts/:accountId/users?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/users#operation=suspend"

querystring = {"operation":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/users#operation=suspend"

queryString <- list(operation = "")

payload <- "{\n  \"UserIdList\": []\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend")

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  \"UserIdList\": []\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/accounts/:accountId/users') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"UserIdList\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/users#operation=suspend";

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

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

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

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

    dbg!(results);
}

echo '{
  "UserIdList": []
}' |  \
  http POST '{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserIdList": []\n}' \
  --output-document \
  - '{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/users?operation=#operation=suspend")! 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}}/accounts/:accountId/users?operation=#operation=unsuspend");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:accountId/users#operation=unsuspend" {:query-params {:operation ""}
                                                                                          :content-type :json
                                                                                          :form-params {:UserIdList []}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserIdList\": []\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}}/accounts/:accountId/users?operation=#operation=unsuspend"),
    Content = new StringContent("{\n  \"UserIdList\": []\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}}/accounts/:accountId/users?operation=#operation=unsuspend");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserIdList\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend"

	payload := strings.NewReader("{\n  \"UserIdList\": []\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/accounts/:accountId/users?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "UserIdList": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserIdList\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserIdList\": []\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  \"UserIdList\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend")
  .header("content-type", "application/json")
  .body("{\n  \"UserIdList\": []\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users#operation=unsuspend',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {UserIdList: []}
};

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

const url = '{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"UserIdList":[]}'
};

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}}/accounts/:accountId/users?operation=#operation=unsuspend',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserIdList": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserIdList\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend")
  .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/accounts/:accountId/users?operation=',
  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({UserIdList: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users#operation=unsuspend',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {UserIdList: []},
  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}}/accounts/:accountId/users#operation=unsuspend');

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

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

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

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}}/accounts/:accountId/users#operation=unsuspend',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {UserIdList: []}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"UserIdList":[]}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend"]
                                                       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}}/accounts/:accountId/users?operation=#operation=unsuspend" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"UserIdList\": []\n}" in

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

 "{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend",
  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([
    'UserIdList' => [
        
    ]
  ]),
  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}}/accounts/:accountId/users?operation=#operation=unsuspend', [
  'body' => '{
  "UserIdList": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/users#operation=unsuspend');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

append(json_encode([
  'UserIdList' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId/users#operation=unsuspend');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/accounts/:accountId/users?operation=#operation=unsuspend' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserIdList": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserIdList": []
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/accounts/:accountId/users?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/users#operation=unsuspend"

querystring = {"operation":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/users#operation=unsuspend"

queryString <- list(operation = "")

payload <- "{\n  \"UserIdList\": []\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend")

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  \"UserIdList\": []\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/accounts/:accountId/users') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"UserIdList\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/users#operation=unsuspend";

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

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

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

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

    dbg!(results);
}

echo '{
  "UserIdList": []
}' |  \
  http POST '{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserIdList": []\n}' \
  --output-document \
  - '{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/users?operation=#operation=unsuspend")! 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}}/phone-numbers?operation=#operation=batch-update");

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  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/phone-numbers#operation=batch-update" {:query-params {:operation ""}
                                                                                 :content-type :json
                                                                                 :form-params {:UpdatePhoneNumberRequestItems [{:PhoneNumberId ""
                                                                                                                                :ProductType ""
                                                                                                                                :CallingName ""}]}})

require "http/client"

url = "{{baseUrl}}/phone-numbers?operation=#operation=batch-update"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\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}}/phone-numbers?operation=#operation=batch-update"),
    Content = new StringContent("{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\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}}/phone-numbers?operation=#operation=batch-update");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/phone-numbers?operation=#operation=batch-update"

	payload := strings.NewReader("{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\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/phone-numbers?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 132

{
  "UpdatePhoneNumberRequestItems": [
    {
      "PhoneNumberId": "",
      "ProductType": "",
      "CallingName": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/phone-numbers?operation=#operation=batch-update")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/phone-numbers?operation=#operation=batch-update"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\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  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/phone-numbers?operation=#operation=batch-update")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/phone-numbers?operation=#operation=batch-update")
  .header("content-type", "application/json")
  .body("{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  UpdatePhoneNumberRequestItems: [
    {
      PhoneNumberId: '',
      ProductType: '',
      CallingName: ''
    }
  ]
});

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-numbers?operation=#operation=batch-update');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/phone-numbers#operation=batch-update',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {
    UpdatePhoneNumberRequestItems: [{PhoneNumberId: '', ProductType: '', CallingName: ''}]
  }
};

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

const url = '{{baseUrl}}/phone-numbers?operation=#operation=batch-update';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"UpdatePhoneNumberRequestItems":[{"PhoneNumberId":"","ProductType":"","CallingName":""}]}'
};

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-numbers?operation=#operation=batch-update',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UpdatePhoneNumberRequestItems": [\n    {\n      "PhoneNumberId": "",\n      "ProductType": "",\n      "CallingName": ""\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  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/phone-numbers?operation=#operation=batch-update")
  .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-numbers?operation=',
  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({
  UpdatePhoneNumberRequestItems: [{PhoneNumberId: '', ProductType: '', CallingName: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/phone-numbers#operation=batch-update',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {
    UpdatePhoneNumberRequestItems: [{PhoneNumberId: '', ProductType: '', CallingName: ''}]
  },
  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-numbers#operation=batch-update');

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

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

req.type('json');
req.send({
  UpdatePhoneNumberRequestItems: [
    {
      PhoneNumberId: '',
      ProductType: '',
      CallingName: ''
    }
  ]
});

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-numbers#operation=batch-update',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {
    UpdatePhoneNumberRequestItems: [{PhoneNumberId: '', ProductType: '', CallingName: ''}]
  }
};

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

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

const url = '{{baseUrl}}/phone-numbers?operation=#operation=batch-update';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"UpdatePhoneNumberRequestItems":[{"PhoneNumberId":"","ProductType":"","CallingName":""}]}'
};

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 = @{ @"UpdatePhoneNumberRequestItems": @[ @{ @"PhoneNumberId": @"", @"ProductType": @"", @"CallingName": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/phone-numbers?operation=#operation=batch-update"]
                                                       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-numbers?operation=#operation=batch-update" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/phone-numbers?operation=#operation=batch-update",
  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([
    'UpdatePhoneNumberRequestItems' => [
        [
                'PhoneNumberId' => '',
                'ProductType' => '',
                'CallingName' => ''
        ]
    ]
  ]),
  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-numbers?operation=#operation=batch-update', [
  'body' => '{
  "UpdatePhoneNumberRequestItems": [
    {
      "PhoneNumberId": "",
      "ProductType": "",
      "CallingName": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/phone-numbers#operation=batch-update');
$request->setMethod(HTTP_METH_POST);

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UpdatePhoneNumberRequestItems' => [
    [
        'PhoneNumberId' => '',
        'ProductType' => '',
        'CallingName' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'UpdatePhoneNumberRequestItems' => [
    [
        'PhoneNumberId' => '',
        'ProductType' => '',
        'CallingName' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/phone-numbers#operation=batch-update');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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-numbers?operation=#operation=batch-update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UpdatePhoneNumberRequestItems": [
    {
      "PhoneNumberId": "",
      "ProductType": "",
      "CallingName": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/phone-numbers?operation=#operation=batch-update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UpdatePhoneNumberRequestItems": [
    {
      "PhoneNumberId": "",
      "ProductType": "",
      "CallingName": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/phone-numbers?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/phone-numbers#operation=batch-update"

querystring = {"operation":""}

payload = { "UpdatePhoneNumberRequestItems": [
        {
            "PhoneNumberId": "",
            "ProductType": "",
            "CallingName": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/phone-numbers#operation=batch-update"

queryString <- list(operation = "")

payload <- "{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/phone-numbers?operation=#operation=batch-update")

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  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\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/phone-numbers') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"UpdatePhoneNumberRequestItems\": [\n    {\n      \"PhoneNumberId\": \"\",\n      \"ProductType\": \"\",\n      \"CallingName\": \"\"\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}}/phone-numbers#operation=batch-update";

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

    let payload = json!({"UpdatePhoneNumberRequestItems": (
            json!({
                "PhoneNumberId": "",
                "ProductType": "",
                "CallingName": ""
            })
        )});

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

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

    dbg!(results);
}

echo '{
  "UpdatePhoneNumberRequestItems": [
    {
      "PhoneNumberId": "",
      "ProductType": "",
      "CallingName": ""
    }
  ]
}' |  \
  http POST '{{baseUrl}}/phone-numbers?operation=#operation=batch-update' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "UpdatePhoneNumberRequestItems": [\n    {\n      "PhoneNumberId": "",\n      "ProductType": "",\n      "CallingName": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/phone-numbers?operation=#operation=batch-update'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["UpdatePhoneNumberRequestItems": [
    [
      "PhoneNumberId": "",
      "ProductType": "",
      "CallingName": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/phone-numbers?operation=#operation=batch-update")! 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}}/accounts/:accountId/users");

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  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:accountId/users" {:content-type :json
                                                                      :form-params {:UpdateUserRequestItems [{:UserId ""
                                                                                                              :LicenseType ""
                                                                                                              :UserType ""
                                                                                                              :AlexaForBusinessMetadata ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/users"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\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}}/accounts/:accountId/users"),
    Content = new StringContent("{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\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}}/accounts/:accountId/users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/users"

	payload := strings.NewReader("{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\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/accounts/:accountId/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 153

{
  "UpdateUserRequestItems": [
    {
      "UserId": "",
      "LicenseType": "",
      "UserType": "",
      "AlexaForBusinessMetadata": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId/users")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/users"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\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  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId/users")
  .header("content-type", "application/json")
  .body("{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  UpdateUserRequestItems: [
    {
      UserId: '',
      LicenseType: '',
      UserType: '',
      AlexaForBusinessMetadata: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users',
  headers: {'content-type': 'application/json'},
  data: {
    UpdateUserRequestItems: [{UserId: '', LicenseType: '', UserType: '', AlexaForBusinessMetadata: ''}]
  }
};

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

const url = '{{baseUrl}}/accounts/:accountId/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"UpdateUserRequestItems":[{"UserId":"","LicenseType":"","UserType":"","AlexaForBusinessMetadata":""}]}'
};

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}}/accounts/:accountId/users',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UpdateUserRequestItems": [\n    {\n      "UserId": "",\n      "LicenseType": "",\n      "UserType": "",\n      "AlexaForBusinessMetadata": ""\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  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users")
  .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/accounts/:accountId/users',
  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({
  UpdateUserRequestItems: [{UserId: '', LicenseType: '', UserType: '', AlexaForBusinessMetadata: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users',
  headers: {'content-type': 'application/json'},
  body: {
    UpdateUserRequestItems: [{UserId: '', LicenseType: '', UserType: '', AlexaForBusinessMetadata: ''}]
  },
  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}}/accounts/:accountId/users');

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

req.type('json');
req.send({
  UpdateUserRequestItems: [
    {
      UserId: '',
      LicenseType: '',
      UserType: '',
      AlexaForBusinessMetadata: ''
    }
  ]
});

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}}/accounts/:accountId/users',
  headers: {'content-type': 'application/json'},
  data: {
    UpdateUserRequestItems: [{UserId: '', LicenseType: '', UserType: '', AlexaForBusinessMetadata: ''}]
  }
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"UpdateUserRequestItems":[{"UserId":"","LicenseType":"","UserType":"","AlexaForBusinessMetadata":""}]}'
};

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 = @{ @"UpdateUserRequestItems": @[ @{ @"UserId": @"", @"LicenseType": @"", @"UserType": @"", @"AlexaForBusinessMetadata": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/users"]
                                                       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}}/accounts/:accountId/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/accounts/:accountId/users",
  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([
    'UpdateUserRequestItems' => [
        [
                'UserId' => '',
                'LicenseType' => '',
                'UserType' => '',
                'AlexaForBusinessMetadata' => ''
        ]
    ]
  ]),
  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}}/accounts/:accountId/users', [
  'body' => '{
  "UpdateUserRequestItems": [
    {
      "UserId": "",
      "LicenseType": "",
      "UserType": "",
      "AlexaForBusinessMetadata": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/users');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UpdateUserRequestItems' => [
    [
        'UserId' => '',
        'LicenseType' => '',
        'UserType' => '',
        'AlexaForBusinessMetadata' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'UpdateUserRequestItems' => [
    [
        'UserId' => '',
        'LicenseType' => '',
        'UserType' => '',
        'AlexaForBusinessMetadata' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId/users');
$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}}/accounts/:accountId/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UpdateUserRequestItems": [
    {
      "UserId": "",
      "LicenseType": "",
      "UserType": "",
      "AlexaForBusinessMetadata": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UpdateUserRequestItems": [
    {
      "UserId": "",
      "LicenseType": "",
      "UserType": "",
      "AlexaForBusinessMetadata": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/accounts/:accountId/users", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/users"

payload = { "UpdateUserRequestItems": [
        {
            "UserId": "",
            "LicenseType": "",
            "UserType": "",
            "AlexaForBusinessMetadata": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/users"

payload <- "{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\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}}/accounts/:accountId/users")

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  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\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/accounts/:accountId/users') do |req|
  req.body = "{\n  \"UpdateUserRequestItems\": [\n    {\n      \"UserId\": \"\",\n      \"LicenseType\": \"\",\n      \"UserType\": \"\",\n      \"AlexaForBusinessMetadata\": \"\"\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}}/accounts/:accountId/users";

    let payload = json!({"UpdateUserRequestItems": (
            json!({
                "UserId": "",
                "LicenseType": "",
                "UserType": "",
                "AlexaForBusinessMetadata": ""
            })
        )});

    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 '{
  "UpdateUserRequestItems": [
    {
      "UserId": "",
      "LicenseType": "",
      "UserType": "",
      "AlexaForBusinessMetadata": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:accountId/users \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "UpdateUserRequestItems": [\n    {\n      "UserId": "",\n      "LicenseType": "",\n      "UserType": "",\n      "AlexaForBusinessMetadata": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/users

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["UpdateUserRequestItems": [
    [
      "UserId": "",
      "LicenseType": "",
      "UserType": "",
      "AlexaForBusinessMetadata": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/users")! 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}}/accounts");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts" {:content-type :json
                                                     :form-params {:Name ""}})

require "http/client"

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

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"Name\": \"\"\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/accounts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts',
  headers: {'content-type': 'application/json'},
  data: {Name: ''}
};

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

const url = '{{baseUrl}}/accounts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

const request = require('request');

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

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

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

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}}/accounts',
  headers: {'content-type': 'application/json'},
  data: {Name: ''}
};

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

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

const url = '{{baseUrl}}/accounts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

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

 "{{baseUrl}}/accounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  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}}/accounts', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

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

import http.client

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

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

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

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

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

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

import requests

url = "{{baseUrl}}/accounts"

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

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

print(response.json())

library(httr)

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

payload <- "{\n  \"Name\": \"\"\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}}/accounts")

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}"

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/accounts') do |req|
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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": ""
}' |  \
  http POST {{baseUrl}}/accounts \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/app-instances");

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  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/app-instances" {:content-type :json
                                                          :form-params {:Name ""
                                                                        :Metadata ""
                                                                        :ClientRequestToken ""
                                                                        :Tags [{:Key ""
                                                                                :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/app-instances"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/app-instances"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/app-instances");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/app-instances"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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/app-instances HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 126

{
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/app-instances")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/app-instances"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/app-instances")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/app-instances")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Metadata: '',
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/app-instances',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Metadata: '', ClientRequestToken: '', Tags: [{Key: '', Value: ''}]}
};

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

const url = '{{baseUrl}}/app-instances';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Metadata":"","ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/app-instances',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Metadata": "",\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\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  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/app-instances")
  .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/app-instances',
  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: '', Metadata: '', ClientRequestToken: '', Tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/app-instances',
  headers: {'content-type': 'application/json'},
  body: {Name: '', Metadata: '', ClientRequestToken: '', Tags: [{Key: '', Value: ''}]},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/app-instances');

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

req.type('json');
req.send({
  Name: '',
  Metadata: '',
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/app-instances',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Metadata: '', ClientRequestToken: '', Tags: [{Key: '', Value: ''}]}
};

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

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

const url = '{{baseUrl}}/app-instances';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Metadata":"","ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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": @"",
                              @"Metadata": @"",
                              @"ClientRequestToken": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/app-instances"]
                                                       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}}/app-instances" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/app-instances",
  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' => '',
    'Metadata' => '',
    'ClientRequestToken' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  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}}/app-instances', [
  'body' => '{
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/app-instances');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Metadata' => '',
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Metadata' => '',
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/app-instances');
$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}}/app-instances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/app-instances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/app-instances", payload, headers)

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

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

import requests

url = "{{baseUrl}}/app-instances"

payload = {
    "Name": "",
    "Metadata": "",
    "ClientRequestToken": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/app-instances"

payload <- "{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/app-instances")

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  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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/app-instances') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/app-instances";

    let payload = json!({
        "Name": "",
        "Metadata": "",
        "ClientRequestToken": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    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": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/app-instances \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Metadata": "",\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/app-instances

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/app-instances")! 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}}/app-instances/:appInstanceArn/admins");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/app-instances/:appInstanceArn/admins" {:content-type :json
                                                                                 :form-params {:AppInstanceAdminArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/app-instances/:appInstanceArn/admins"

	payload := strings.NewReader("{\n  \"AppInstanceAdminArn\": \"\"\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/app-instances/:appInstanceArn/admins HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 31

{
  "AppInstanceAdminArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/app-instances/:appInstanceArn/admins")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AppInstanceAdminArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/app-instances/:appInstanceArn/admins")
  .header("content-type", "application/json")
  .body("{\n  \"AppInstanceAdminArn\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/app-instances/:appInstanceArn/admins');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/app-instances/:appInstanceArn/admins',
  headers: {'content-type': 'application/json'},
  data: {AppInstanceAdminArn: ''}
};

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

const url = '{{baseUrl}}/app-instances/:appInstanceArn/admins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AppInstanceAdminArn":""}'
};

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}}/app-instances/:appInstanceArn/admins',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AppInstanceAdminArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AppInstanceAdminArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/app-instances/:appInstanceArn/admins")
  .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/app-instances/:appInstanceArn/admins',
  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({AppInstanceAdminArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/app-instances/:appInstanceArn/admins',
  headers: {'content-type': 'application/json'},
  body: {AppInstanceAdminArn: ''},
  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}}/app-instances/:appInstanceArn/admins');

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

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

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}}/app-instances/:appInstanceArn/admins',
  headers: {'content-type': 'application/json'},
  data: {AppInstanceAdminArn: ''}
};

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

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

const url = '{{baseUrl}}/app-instances/:appInstanceArn/admins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AppInstanceAdminArn":""}'
};

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

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

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

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

 "{{baseUrl}}/app-instances/:appInstanceArn/admins",
  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([
    'AppInstanceAdminArn' => ''
  ]),
  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}}/app-instances/:appInstanceArn/admins', [
  'body' => '{
  "AppInstanceAdminArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/app-instances/:appInstanceArn/admins');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'AppInstanceAdminArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/app-instances/:appInstanceArn/admins');
$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}}/app-instances/:appInstanceArn/admins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AppInstanceAdminArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/app-instances/:appInstanceArn/admins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AppInstanceAdminArn": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/app-instances/:appInstanceArn/admins", payload, headers)

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

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

import requests

url = "{{baseUrl}}/app-instances/:appInstanceArn/admins"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/app-instances/:appInstanceArn/admins"

payload <- "{\n  \"AppInstanceAdminArn\": \"\"\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}}/app-instances/:appInstanceArn/admins")

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  \"AppInstanceAdminArn\": \"\"\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/app-instances/:appInstanceArn/admins') do |req|
  req.body = "{\n  \"AppInstanceAdminArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/app-instances/:appInstanceArn/admins";

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

    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 '{
  "AppInstanceAdminArn": ""
}' |  \
  http POST {{baseUrl}}/app-instances/:appInstanceArn/admins \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AppInstanceAdminArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/app-instances/:appInstanceArn/admins

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/app-instances/:appInstanceArn/admins")! 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}}/app-instance-users");

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  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/app-instance-users" {:content-type :json
                                                               :form-params {:AppInstanceArn ""
                                                                             :AppInstanceUserId ""
                                                                             :Name ""
                                                                             :Metadata ""
                                                                             :ClientRequestToken ""
                                                                             :Tags [{:Key ""
                                                                                     :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/app-instance-users"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/app-instance-users"),
    Content = new StringContent("{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/app-instance-users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/app-instance-users"

	payload := strings.NewReader("{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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/app-instance-users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 177

{
  "AppInstanceArn": "",
  "AppInstanceUserId": "",
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/app-instance-users")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/app-instance-users"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/app-instance-users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/app-instance-users")
  .header("content-type", "application/json")
  .body("{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  AppInstanceArn: '',
  AppInstanceUserId: '',
  Name: '',
  Metadata: '',
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/app-instance-users',
  headers: {'content-type': 'application/json'},
  data: {
    AppInstanceArn: '',
    AppInstanceUserId: '',
    Name: '',
    Metadata: '',
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/app-instance-users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AppInstanceArn":"","AppInstanceUserId":"","Name":"","Metadata":"","ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/app-instance-users',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AppInstanceArn": "",\n  "AppInstanceUserId": "",\n  "Name": "",\n  "Metadata": "",\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\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  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/app-instance-users")
  .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/app-instance-users',
  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({
  AppInstanceArn: '',
  AppInstanceUserId: '',
  Name: '',
  Metadata: '',
  ClientRequestToken: '',
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/app-instance-users',
  headers: {'content-type': 'application/json'},
  body: {
    AppInstanceArn: '',
    AppInstanceUserId: '',
    Name: '',
    Metadata: '',
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/app-instance-users');

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

req.type('json');
req.send({
  AppInstanceArn: '',
  AppInstanceUserId: '',
  Name: '',
  Metadata: '',
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/app-instance-users',
  headers: {'content-type': 'application/json'},
  data: {
    AppInstanceArn: '',
    AppInstanceUserId: '',
    Name: '',
    Metadata: '',
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/app-instance-users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AppInstanceArn":"","AppInstanceUserId":"","Name":"","Metadata":"","ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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 = @{ @"AppInstanceArn": @"",
                              @"AppInstanceUserId": @"",
                              @"Name": @"",
                              @"Metadata": @"",
                              @"ClientRequestToken": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/app-instance-users"]
                                                       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}}/app-instance-users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/app-instance-users",
  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([
    'AppInstanceArn' => '',
    'AppInstanceUserId' => '',
    'Name' => '',
    'Metadata' => '',
    'ClientRequestToken' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  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}}/app-instance-users', [
  'body' => '{
  "AppInstanceArn": "",
  "AppInstanceUserId": "",
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/app-instance-users');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AppInstanceArn' => '',
  'AppInstanceUserId' => '',
  'Name' => '',
  'Metadata' => '',
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'AppInstanceArn' => '',
  'AppInstanceUserId' => '',
  'Name' => '',
  'Metadata' => '',
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/app-instance-users');
$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}}/app-instance-users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AppInstanceArn": "",
  "AppInstanceUserId": "",
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/app-instance-users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AppInstanceArn": "",
  "AppInstanceUserId": "",
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/app-instance-users", payload, headers)

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

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

import requests

url = "{{baseUrl}}/app-instance-users"

payload = {
    "AppInstanceArn": "",
    "AppInstanceUserId": "",
    "Name": "",
    "Metadata": "",
    "ClientRequestToken": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/app-instance-users"

payload <- "{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/app-instance-users")

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  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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/app-instance-users') do |req|
  req.body = "{\n  \"AppInstanceArn\": \"\",\n  \"AppInstanceUserId\": \"\",\n  \"Name\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/app-instance-users";

    let payload = json!({
        "AppInstanceArn": "",
        "AppInstanceUserId": "",
        "Name": "",
        "Metadata": "",
        "ClientRequestToken": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    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 '{
  "AppInstanceArn": "",
  "AppInstanceUserId": "",
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/app-instance-users \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AppInstanceArn": "",\n  "AppInstanceUserId": "",\n  "Name": "",\n  "Metadata": "",\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/app-instance-users

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AppInstanceArn": "",
  "AppInstanceUserId": "",
  "Name": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/app-instance-users")! 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}}/meetings/:meetingId/attendees");

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  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/meetings/:meetingId/attendees" {:content-type :json
                                                                          :form-params {:ExternalUserId ""
                                                                                        :Tags [{:Key ""
                                                                                                :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/meetings/:meetingId/attendees"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/meetings/:meetingId/attendees"),
    Content = new StringContent("{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/meetings/:meetingId/attendees");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/meetings/:meetingId/attendees"

	payload := strings.NewReader("{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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/meetings/:meetingId/attendees HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 90

{
  "ExternalUserId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/meetings/:meetingId/attendees")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/meetings/:meetingId/attendees"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/meetings/:meetingId/attendees")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/meetings/:meetingId/attendees")
  .header("content-type", "application/json")
  .body("{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  ExternalUserId: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings/:meetingId/attendees',
  headers: {'content-type': 'application/json'},
  data: {ExternalUserId: '', Tags: [{Key: '', Value: ''}]}
};

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

const url = '{{baseUrl}}/meetings/:meetingId/attendees';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ExternalUserId":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/meetings/:meetingId/attendees',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ExternalUserId": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\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  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/meetings/:meetingId/attendees")
  .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/meetings/:meetingId/attendees',
  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({ExternalUserId: '', Tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings/:meetingId/attendees',
  headers: {'content-type': 'application/json'},
  body: {ExternalUserId: '', Tags: [{Key: '', Value: ''}]},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/meetings/:meetingId/attendees');

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

req.type('json');
req.send({
  ExternalUserId: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings/:meetingId/attendees',
  headers: {'content-type': 'application/json'},
  data: {ExternalUserId: '', Tags: [{Key: '', Value: ''}]}
};

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

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

const url = '{{baseUrl}}/meetings/:meetingId/attendees';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ExternalUserId":"","Tags":[{"Key":"","Value":""}]}'
};

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 = @{ @"ExternalUserId": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/meetings/:meetingId/attendees"]
                                                       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}}/meetings/:meetingId/attendees" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/meetings/:meetingId/attendees",
  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([
    'ExternalUserId' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  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}}/meetings/:meetingId/attendees', [
  'body' => '{
  "ExternalUserId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/meetings/:meetingId/attendees');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ExternalUserId' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/meetings/:meetingId/attendees');
$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}}/meetings/:meetingId/attendees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ExternalUserId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/meetings/:meetingId/attendees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ExternalUserId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/meetings/:meetingId/attendees", payload, headers)

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

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

import requests

url = "{{baseUrl}}/meetings/:meetingId/attendees"

payload = {
    "ExternalUserId": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/meetings/:meetingId/attendees"

payload <- "{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/meetings/:meetingId/attendees")

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  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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/meetings/:meetingId/attendees') do |req|
  req.body = "{\n  \"ExternalUserId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/meetings/:meetingId/attendees";

    let payload = json!({
        "ExternalUserId": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    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 '{
  "ExternalUserId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/meetings/:meetingId/attendees \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ExternalUserId": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/meetings/:meetingId/attendees

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/meetings/:meetingId/attendees")! 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}}/accounts/:accountId/bots");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:accountId/bots" {:content-type :json
                                                                     :form-params {:DisplayName ""
                                                                                   :Domain ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:accountId/bots"

	payload := strings.NewReader("{\n  \"DisplayName\": \"\",\n  \"Domain\": \"\"\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/accounts/:accountId/bots HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "DisplayName": "",
  "Domain": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId/bots")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DisplayName\": \"\",\n  \"Domain\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId/bots")
  .header("content-type", "application/json")
  .body("{\n  \"DisplayName\": \"\",\n  \"Domain\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DisplayName: '',
  Domain: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/bots',
  headers: {'content-type': 'application/json'},
  data: {DisplayName: '', Domain: ''}
};

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

const url = '{{baseUrl}}/accounts/:accountId/bots';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DisplayName":"","Domain":""}'
};

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}}/accounts/:accountId/bots',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DisplayName": "",\n  "Domain": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DisplayName\": \"\",\n  \"Domain\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/bots")
  .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/accounts/:accountId/bots',
  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({DisplayName: '', Domain: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/bots',
  headers: {'content-type': 'application/json'},
  body: {DisplayName: '', Domain: ''},
  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}}/accounts/:accountId/bots');

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

req.type('json');
req.send({
  DisplayName: '',
  Domain: ''
});

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}}/accounts/:accountId/bots',
  headers: {'content-type': 'application/json'},
  data: {DisplayName: '', Domain: ''}
};

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

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

const url = '{{baseUrl}}/accounts/:accountId/bots';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DisplayName":"","Domain":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/bots"]
                                                       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}}/accounts/:accountId/bots" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DisplayName\": \"\",\n  \"Domain\": \"\"\n}" in

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

 "{{baseUrl}}/accounts/:accountId/bots",
  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([
    'DisplayName' => '',
    'Domain' => ''
  ]),
  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}}/accounts/:accountId/bots', [
  'body' => '{
  "DisplayName": "",
  "Domain": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/bots');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'DisplayName' => '',
  'Domain' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId/bots');
$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}}/accounts/:accountId/bots' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DisplayName": "",
  "Domain": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/bots' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DisplayName": "",
  "Domain": ""
}'

import http.client

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

payload = "{\n  \"DisplayName\": \"\",\n  \"Domain\": \"\"\n}"

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

conn.request("POST", "/baseUrl/accounts/:accountId/bots", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:accountId/bots"

payload = {
    "DisplayName": "",
    "Domain": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/bots"

payload <- "{\n  \"DisplayName\": \"\",\n  \"Domain\": \"\"\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}}/accounts/:accountId/bots")

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  \"DisplayName\": \"\",\n  \"Domain\": \"\"\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/accounts/:accountId/bots') do |req|
  req.body = "{\n  \"DisplayName\": \"\",\n  \"Domain\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "DisplayName": "",
        "Domain": ""
    });

    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 '{
  "DisplayName": "",
  "Domain": ""
}' |  \
  http POST {{baseUrl}}/accounts/:accountId/bots \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DisplayName": "",\n  "Domain": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/bots

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/bots")! 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}}/channels");

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  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/channels" {:content-type :json
                                                     :form-params {:AppInstanceArn ""
                                                                   :Name ""
                                                                   :Mode ""
                                                                   :Privacy ""
                                                                   :Metadata ""
                                                                   :ClientRequestToken ""
                                                                   :Tags [{:Key ""
                                                                           :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/channels"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/channels"),
    Content = new StringContent("{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/channels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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/channels HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 181

{
  "AppInstanceArn": "",
  "Name": "",
  "Mode": "",
  "Privacy": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/channels")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/channels")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/channels")
  .header("content-type", "application/json")
  .body("{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  AppInstanceArn: '',
  Name: '',
  Mode: '',
  Privacy: '',
  Metadata: '',
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels',
  headers: {'content-type': 'application/json'},
  data: {
    AppInstanceArn: '',
    Name: '',
    Mode: '',
    Privacy: '',
    Metadata: '',
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AppInstanceArn":"","Name":"","Mode":"","Privacy":"","Metadata":"","ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/channels',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AppInstanceArn": "",\n  "Name": "",\n  "Mode": "",\n  "Privacy": "",\n  "Metadata": "",\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\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  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/channels")
  .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/channels',
  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({
  AppInstanceArn: '',
  Name: '',
  Mode: '',
  Privacy: '',
  Metadata: '',
  ClientRequestToken: '',
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels',
  headers: {'content-type': 'application/json'},
  body: {
    AppInstanceArn: '',
    Name: '',
    Mode: '',
    Privacy: '',
    Metadata: '',
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  AppInstanceArn: '',
  Name: '',
  Mode: '',
  Privacy: '',
  Metadata: '',
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels',
  headers: {'content-type': 'application/json'},
  data: {
    AppInstanceArn: '',
    Name: '',
    Mode: '',
    Privacy: '',
    Metadata: '',
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AppInstanceArn":"","Name":"","Mode":"","Privacy":"","Metadata":"","ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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 = @{ @"AppInstanceArn": @"",
                              @"Name": @"",
                              @"Mode": @"",
                              @"Privacy": @"",
                              @"Metadata": @"",
                              @"ClientRequestToken": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/channels"]
                                                       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}}/channels" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/channels",
  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([
    'AppInstanceArn' => '',
    'Name' => '',
    'Mode' => '',
    'Privacy' => '',
    'Metadata' => '',
    'ClientRequestToken' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  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}}/channels', [
  'body' => '{
  "AppInstanceArn": "",
  "Name": "",
  "Mode": "",
  "Privacy": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/channels');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AppInstanceArn' => '',
  'Name' => '',
  'Mode' => '',
  'Privacy' => '',
  'Metadata' => '',
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'AppInstanceArn' => '',
  'Name' => '',
  'Mode' => '',
  'Privacy' => '',
  'Metadata' => '',
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/channels');
$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}}/channels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AppInstanceArn": "",
  "Name": "",
  "Mode": "",
  "Privacy": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AppInstanceArn": "",
  "Name": "",
  "Mode": "",
  "Privacy": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/channels"

payload = {
    "AppInstanceArn": "",
    "Name": "",
    "Mode": "",
    "Privacy": "",
    "Metadata": "",
    "ClientRequestToken": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/channels")

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  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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/channels') do |req|
  req.body = "{\n  \"AppInstanceArn\": \"\",\n  \"Name\": \"\",\n  \"Mode\": \"\",\n  \"Privacy\": \"\",\n  \"Metadata\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\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}}/channels";

    let payload = json!({
        "AppInstanceArn": "",
        "Name": "",
        "Mode": "",
        "Privacy": "",
        "Metadata": "",
        "ClientRequestToken": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    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 '{
  "AppInstanceArn": "",
  "Name": "",
  "Mode": "",
  "Privacy": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/channels \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AppInstanceArn": "",\n  "Name": "",\n  "Mode": "",\n  "Privacy": "",\n  "Metadata": "",\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/channels

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AppInstanceArn": "",
  "Name": "",
  "Mode": "",
  "Privacy": "",
  "Metadata": "",
  "ClientRequestToken": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels")! 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}}/channels/:channelArn/bans");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/channels/:channelArn/bans" {:content-type :json
                                                                      :form-params {:MemberArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/channels/:channelArn/bans"

	payload := strings.NewReader("{\n  \"MemberArn\": \"\"\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/channels/:channelArn/bans HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "MemberArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/channels/:channelArn/bans")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MemberArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/channels/:channelArn/bans")
  .header("content-type", "application/json")
  .body("{\n  \"MemberArn\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels/:channelArn/bans',
  headers: {'content-type': 'application/json'},
  data: {MemberArn: ''}
};

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

const url = '{{baseUrl}}/channels/:channelArn/bans';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MemberArn":""}'
};

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}}/channels/:channelArn/bans',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MemberArn": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels/:channelArn/bans',
  headers: {'content-type': 'application/json'},
  body: {MemberArn: ''},
  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}}/channels/:channelArn/bans');

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

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

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}}/channels/:channelArn/bans',
  headers: {'content-type': 'application/json'},
  data: {MemberArn: ''}
};

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

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

const url = '{{baseUrl}}/channels/:channelArn/bans';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MemberArn":""}'
};

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

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

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

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

 "{{baseUrl}}/channels/:channelArn/bans",
  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([
    'MemberArn' => ''
  ]),
  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}}/channels/:channelArn/bans', [
  'body' => '{
  "MemberArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channelArn/bans');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'MemberArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/channels/:channelArn/bans');
$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}}/channels/:channelArn/bans' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MemberArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channelArn/bans' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MemberArn": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/channels/:channelArn/bans", payload, headers)

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

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

import requests

url = "{{baseUrl}}/channels/:channelArn/bans"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channelArn/bans"

payload <- "{\n  \"MemberArn\": \"\"\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}}/channels/:channelArn/bans")

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  \"MemberArn\": \"\"\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/channels/:channelArn/bans') do |req|
  req.body = "{\n  \"MemberArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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 '{
  "MemberArn": ""
}' |  \
  http POST {{baseUrl}}/channels/:channelArn/bans \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "MemberArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/channels/:channelArn/bans

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channelArn/bans")! 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}}/channels/:channelArn/memberships");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/channels/:channelArn/memberships" {:content-type :json
                                                                             :form-params {:MemberArn ""
                                                                                           :Type ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/channels/:channelArn/memberships"

	payload := strings.NewReader("{\n  \"MemberArn\": \"\",\n  \"Type\": \"\"\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/channels/:channelArn/memberships HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "MemberArn": "",
  "Type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/channels/:channelArn/memberships")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MemberArn\": \"\",\n  \"Type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/channels/:channelArn/memberships")
  .header("content-type", "application/json")
  .body("{\n  \"MemberArn\": \"\",\n  \"Type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MemberArn: '',
  Type: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels/:channelArn/memberships',
  headers: {'content-type': 'application/json'},
  data: {MemberArn: '', Type: ''}
};

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

const url = '{{baseUrl}}/channels/:channelArn/memberships';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MemberArn":"","Type":""}'
};

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}}/channels/:channelArn/memberships',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MemberArn": "",\n  "Type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MemberArn\": \"\",\n  \"Type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channelArn/memberships")
  .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/channels/:channelArn/memberships',
  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({MemberArn: '', Type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels/:channelArn/memberships',
  headers: {'content-type': 'application/json'},
  body: {MemberArn: '', Type: ''},
  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}}/channels/:channelArn/memberships');

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

req.type('json');
req.send({
  MemberArn: '',
  Type: ''
});

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}}/channels/:channelArn/memberships',
  headers: {'content-type': 'application/json'},
  data: {MemberArn: '', Type: ''}
};

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

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

const url = '{{baseUrl}}/channels/:channelArn/memberships';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MemberArn":"","Type":""}'
};

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

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

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

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

 "{{baseUrl}}/channels/:channelArn/memberships",
  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([
    'MemberArn' => '',
    'Type' => ''
  ]),
  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}}/channels/:channelArn/memberships', [
  'body' => '{
  "MemberArn": "",
  "Type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channelArn/memberships');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'MemberArn' => '',
  'Type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/channels/:channelArn/memberships');
$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}}/channels/:channelArn/memberships' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MemberArn": "",
  "Type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channelArn/memberships' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MemberArn": "",
  "Type": ""
}'

import http.client

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

payload = "{\n  \"MemberArn\": \"\",\n  \"Type\": \"\"\n}"

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

conn.request("POST", "/baseUrl/channels/:channelArn/memberships", payload, headers)

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

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

import requests

url = "{{baseUrl}}/channels/:channelArn/memberships"

payload = {
    "MemberArn": "",
    "Type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channelArn/memberships"

payload <- "{\n  \"MemberArn\": \"\",\n  \"Type\": \"\"\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}}/channels/:channelArn/memberships")

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  \"MemberArn\": \"\",\n  \"Type\": \"\"\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/channels/:channelArn/memberships') do |req|
  req.body = "{\n  \"MemberArn\": \"\",\n  \"Type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "MemberArn": "",
        "Type": ""
    });

    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 '{
  "MemberArn": "",
  "Type": ""
}' |  \
  http POST {{baseUrl}}/channels/:channelArn/memberships \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "MemberArn": "",\n  "Type": ""\n}' \
  --output-document \
  - {{baseUrl}}/channels/:channelArn/memberships

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channelArn/memberships")! 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}}/channels/:channelArn/moderators");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/channels/:channelArn/moderators" {:content-type :json
                                                                            :form-params {:ChannelModeratorArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/channels/:channelArn/moderators"

	payload := strings.NewReader("{\n  \"ChannelModeratorArn\": \"\"\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/channels/:channelArn/moderators HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 31

{
  "ChannelModeratorArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/channels/:channelArn/moderators")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ChannelModeratorArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/channels/:channelArn/moderators")
  .header("content-type", "application/json")
  .body("{\n  \"ChannelModeratorArn\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels/:channelArn/moderators',
  headers: {'content-type': 'application/json'},
  data: {ChannelModeratorArn: ''}
};

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

const url = '{{baseUrl}}/channels/:channelArn/moderators';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ChannelModeratorArn":""}'
};

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}}/channels/:channelArn/moderators',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ChannelModeratorArn": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/channels/:channelArn/moderators',
  headers: {'content-type': 'application/json'},
  body: {ChannelModeratorArn: ''},
  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}}/channels/:channelArn/moderators');

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

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

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}}/channels/:channelArn/moderators',
  headers: {'content-type': 'application/json'},
  data: {ChannelModeratorArn: ''}
};

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

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

const url = '{{baseUrl}}/channels/:channelArn/moderators';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ChannelModeratorArn":""}'
};

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

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

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

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

 "{{baseUrl}}/channels/:channelArn/moderators",
  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([
    'ChannelModeratorArn' => ''
  ]),
  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}}/channels/:channelArn/moderators', [
  'body' => '{
  "ChannelModeratorArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channelArn/moderators');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ChannelModeratorArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/channels/:channelArn/moderators');
$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}}/channels/:channelArn/moderators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ChannelModeratorArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channelArn/moderators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ChannelModeratorArn": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/channels/:channelArn/moderators", payload, headers)

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

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

import requests

url = "{{baseUrl}}/channels/:channelArn/moderators"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channelArn/moderators"

payload <- "{\n  \"ChannelModeratorArn\": \"\"\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}}/channels/:channelArn/moderators")

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  \"ChannelModeratorArn\": \"\"\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/channels/:channelArn/moderators') do |req|
  req.body = "{\n  \"ChannelModeratorArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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 '{
  "ChannelModeratorArn": ""
}' |  \
  http POST {{baseUrl}}/channels/:channelArn/moderators \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ChannelModeratorArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/channels/:channelArn/moderators

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channelArn/moderators")! 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}}/media-capture-pipelines");

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  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/media-capture-pipelines" {:content-type :json
                                                                    :form-params {:SourceType ""
                                                                                  :SourceArn ""
                                                                                  :SinkType ""
                                                                                  :SinkArn ""
                                                                                  :ClientRequestToken ""
                                                                                  :ChimeSdkMeetingConfiguration {:SourceConfiguration ""
                                                                                                                 :ArtifactsConfiguration ""}}})

require "http/client"

url = "{{baseUrl}}/media-capture-pipelines"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\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}}/media-capture-pipelines"),
    Content = new StringContent("{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\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}}/media-capture-pipelines");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/media-capture-pipelines"

	payload := strings.NewReader("{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\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/media-capture-pipelines HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 209

{
  "SourceType": "",
  "SourceArn": "",
  "SinkType": "",
  "SinkArn": "",
  "ClientRequestToken": "",
  "ChimeSdkMeetingConfiguration": {
    "SourceConfiguration": "",
    "ArtifactsConfiguration": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/media-capture-pipelines")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/media-capture-pipelines"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\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  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/media-capture-pipelines")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/media-capture-pipelines")
  .header("content-type", "application/json")
  .body("{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  SourceType: '',
  SourceArn: '',
  SinkType: '',
  SinkArn: '',
  ClientRequestToken: '',
  ChimeSdkMeetingConfiguration: {
    SourceConfiguration: '',
    ArtifactsConfiguration: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/media-capture-pipelines',
  headers: {'content-type': 'application/json'},
  data: {
    SourceType: '',
    SourceArn: '',
    SinkType: '',
    SinkArn: '',
    ClientRequestToken: '',
    ChimeSdkMeetingConfiguration: {SourceConfiguration: '', ArtifactsConfiguration: ''}
  }
};

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

const url = '{{baseUrl}}/media-capture-pipelines';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SourceType":"","SourceArn":"","SinkType":"","SinkArn":"","ClientRequestToken":"","ChimeSdkMeetingConfiguration":{"SourceConfiguration":"","ArtifactsConfiguration":""}}'
};

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}}/media-capture-pipelines',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SourceType": "",\n  "SourceArn": "",\n  "SinkType": "",\n  "SinkArn": "",\n  "ClientRequestToken": "",\n  "ChimeSdkMeetingConfiguration": {\n    "SourceConfiguration": "",\n    "ArtifactsConfiguration": ""\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  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/media-capture-pipelines")
  .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/media-capture-pipelines',
  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({
  SourceType: '',
  SourceArn: '',
  SinkType: '',
  SinkArn: '',
  ClientRequestToken: '',
  ChimeSdkMeetingConfiguration: {SourceConfiguration: '', ArtifactsConfiguration: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/media-capture-pipelines',
  headers: {'content-type': 'application/json'},
  body: {
    SourceType: '',
    SourceArn: '',
    SinkType: '',
    SinkArn: '',
    ClientRequestToken: '',
    ChimeSdkMeetingConfiguration: {SourceConfiguration: '', ArtifactsConfiguration: ''}
  },
  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}}/media-capture-pipelines');

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

req.type('json');
req.send({
  SourceType: '',
  SourceArn: '',
  SinkType: '',
  SinkArn: '',
  ClientRequestToken: '',
  ChimeSdkMeetingConfiguration: {
    SourceConfiguration: '',
    ArtifactsConfiguration: ''
  }
});

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}}/media-capture-pipelines',
  headers: {'content-type': 'application/json'},
  data: {
    SourceType: '',
    SourceArn: '',
    SinkType: '',
    SinkArn: '',
    ClientRequestToken: '',
    ChimeSdkMeetingConfiguration: {SourceConfiguration: '', ArtifactsConfiguration: ''}
  }
};

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

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

const url = '{{baseUrl}}/media-capture-pipelines';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SourceType":"","SourceArn":"","SinkType":"","SinkArn":"","ClientRequestToken":"","ChimeSdkMeetingConfiguration":{"SourceConfiguration":"","ArtifactsConfiguration":""}}'
};

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 = @{ @"SourceType": @"",
                              @"SourceArn": @"",
                              @"SinkType": @"",
                              @"SinkArn": @"",
                              @"ClientRequestToken": @"",
                              @"ChimeSdkMeetingConfiguration": @{ @"SourceConfiguration": @"", @"ArtifactsConfiguration": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/media-capture-pipelines"]
                                                       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}}/media-capture-pipelines" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/media-capture-pipelines",
  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([
    'SourceType' => '',
    'SourceArn' => '',
    'SinkType' => '',
    'SinkArn' => '',
    'ClientRequestToken' => '',
    'ChimeSdkMeetingConfiguration' => [
        'SourceConfiguration' => '',
        'ArtifactsConfiguration' => ''
    ]
  ]),
  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}}/media-capture-pipelines', [
  'body' => '{
  "SourceType": "",
  "SourceArn": "",
  "SinkType": "",
  "SinkArn": "",
  "ClientRequestToken": "",
  "ChimeSdkMeetingConfiguration": {
    "SourceConfiguration": "",
    "ArtifactsConfiguration": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/media-capture-pipelines');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SourceType' => '',
  'SourceArn' => '',
  'SinkType' => '',
  'SinkArn' => '',
  'ClientRequestToken' => '',
  'ChimeSdkMeetingConfiguration' => [
    'SourceConfiguration' => '',
    'ArtifactsConfiguration' => ''
  ]
]));

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

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

append(json_encode([
  'SourceType' => '',
  'SourceArn' => '',
  'SinkType' => '',
  'SinkArn' => '',
  'ClientRequestToken' => '',
  'ChimeSdkMeetingConfiguration' => [
    'SourceConfiguration' => '',
    'ArtifactsConfiguration' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/media-capture-pipelines');
$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}}/media-capture-pipelines' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SourceType": "",
  "SourceArn": "",
  "SinkType": "",
  "SinkArn": "",
  "ClientRequestToken": "",
  "ChimeSdkMeetingConfiguration": {
    "SourceConfiguration": "",
    "ArtifactsConfiguration": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/media-capture-pipelines' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SourceType": "",
  "SourceArn": "",
  "SinkType": "",
  "SinkArn": "",
  "ClientRequestToken": "",
  "ChimeSdkMeetingConfiguration": {
    "SourceConfiguration": "",
    "ArtifactsConfiguration": ""
  }
}'

import http.client

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

payload = "{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/media-capture-pipelines", payload, headers)

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

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

import requests

url = "{{baseUrl}}/media-capture-pipelines"

payload = {
    "SourceType": "",
    "SourceArn": "",
    "SinkType": "",
    "SinkArn": "",
    "ClientRequestToken": "",
    "ChimeSdkMeetingConfiguration": {
        "SourceConfiguration": "",
        "ArtifactsConfiguration": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/media-capture-pipelines"

payload <- "{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\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}}/media-capture-pipelines")

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  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\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/media-capture-pipelines') do |req|
  req.body = "{\n  \"SourceType\": \"\",\n  \"SourceArn\": \"\",\n  \"SinkType\": \"\",\n  \"SinkArn\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ChimeSdkMeetingConfiguration\": {\n    \"SourceConfiguration\": \"\",\n    \"ArtifactsConfiguration\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "SourceType": "",
        "SourceArn": "",
        "SinkType": "",
        "SinkArn": "",
        "ClientRequestToken": "",
        "ChimeSdkMeetingConfiguration": json!({
            "SourceConfiguration": "",
            "ArtifactsConfiguration": ""
        })
    });

    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 '{
  "SourceType": "",
  "SourceArn": "",
  "SinkType": "",
  "SinkArn": "",
  "ClientRequestToken": "",
  "ChimeSdkMeetingConfiguration": {
    "SourceConfiguration": "",
    "ArtifactsConfiguration": ""
  }
}' |  \
  http POST {{baseUrl}}/media-capture-pipelines \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "SourceType": "",\n  "SourceArn": "",\n  "SinkType": "",\n  "SinkArn": "",\n  "ClientRequestToken": "",\n  "ChimeSdkMeetingConfiguration": {\n    "SourceConfiguration": "",\n    "ArtifactsConfiguration": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/media-capture-pipelines

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "SourceType": "",
  "SourceArn": "",
  "SinkType": "",
  "SinkArn": "",
  "ClientRequestToken": "",
  "ChimeSdkMeetingConfiguration": [
    "SourceConfiguration": "",
    "ArtifactsConfiguration": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/media-capture-pipelines")! 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}}/meetings");

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  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/meetings" {:content-type :json
                                                     :form-params {:ClientRequestToken ""
                                                                   :ExternalMeetingId ""
                                                                   :MeetingHostId ""
                                                                   :MediaRegion ""
                                                                   :Tags [{:Key ""
                                                                           :Value ""}]
                                                                   :NotificationsConfiguration {:SnsTopicArn ""
                                                                                                :SqsQueueArn ""}}})

require "http/client"

url = "{{baseUrl}}/meetings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\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}}/meetings"),
    Content = new StringContent("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\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}}/meetings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\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/meetings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 249

{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/meetings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/meetings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\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  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/meetings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/meetings")
  .header("content-type", "application/json")
  .body("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  ClientRequestToken: '',
  ExternalMeetingId: '',
  MeetingHostId: '',
  MediaRegion: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  NotificationsConfiguration: {
    SnsTopicArn: '',
    SqsQueueArn: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings',
  headers: {'content-type': 'application/json'},
  data: {
    ClientRequestToken: '',
    ExternalMeetingId: '',
    MeetingHostId: '',
    MediaRegion: '',
    Tags: [{Key: '', Value: ''}],
    NotificationsConfiguration: {SnsTopicArn: '', SqsQueueArn: ''}
  }
};

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

const url = '{{baseUrl}}/meetings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ClientRequestToken":"","ExternalMeetingId":"","MeetingHostId":"","MediaRegion":"","Tags":[{"Key":"","Value":""}],"NotificationsConfiguration":{"SnsTopicArn":"","SqsQueueArn":""}}'
};

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}}/meetings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientRequestToken": "",\n  "ExternalMeetingId": "",\n  "MeetingHostId": "",\n  "MediaRegion": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "NotificationsConfiguration": {\n    "SnsTopicArn": "",\n    "SqsQueueArn": ""\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  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/meetings")
  .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/meetings',
  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({
  ClientRequestToken: '',
  ExternalMeetingId: '',
  MeetingHostId: '',
  MediaRegion: '',
  Tags: [{Key: '', Value: ''}],
  NotificationsConfiguration: {SnsTopicArn: '', SqsQueueArn: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings',
  headers: {'content-type': 'application/json'},
  body: {
    ClientRequestToken: '',
    ExternalMeetingId: '',
    MeetingHostId: '',
    MediaRegion: '',
    Tags: [{Key: '', Value: ''}],
    NotificationsConfiguration: {SnsTopicArn: '', SqsQueueArn: ''}
  },
  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}}/meetings');

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

req.type('json');
req.send({
  ClientRequestToken: '',
  ExternalMeetingId: '',
  MeetingHostId: '',
  MediaRegion: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  NotificationsConfiguration: {
    SnsTopicArn: '',
    SqsQueueArn: ''
  }
});

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}}/meetings',
  headers: {'content-type': 'application/json'},
  data: {
    ClientRequestToken: '',
    ExternalMeetingId: '',
    MeetingHostId: '',
    MediaRegion: '',
    Tags: [{Key: '', Value: ''}],
    NotificationsConfiguration: {SnsTopicArn: '', SqsQueueArn: ''}
  }
};

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

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

const url = '{{baseUrl}}/meetings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ClientRequestToken":"","ExternalMeetingId":"","MeetingHostId":"","MediaRegion":"","Tags":[{"Key":"","Value":""}],"NotificationsConfiguration":{"SnsTopicArn":"","SqsQueueArn":""}}'
};

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 = @{ @"ClientRequestToken": @"",
                              @"ExternalMeetingId": @"",
                              @"MeetingHostId": @"",
                              @"MediaRegion": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"NotificationsConfiguration": @{ @"SnsTopicArn": @"", @"SqsQueueArn": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/meetings"]
                                                       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}}/meetings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/meetings",
  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([
    'ClientRequestToken' => '',
    'ExternalMeetingId' => '',
    'MeetingHostId' => '',
    'MediaRegion' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'NotificationsConfiguration' => [
        'SnsTopicArn' => '',
        'SqsQueueArn' => ''
    ]
  ]),
  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}}/meetings', [
  'body' => '{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/meetings');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientRequestToken' => '',
  'ExternalMeetingId' => '',
  'MeetingHostId' => '',
  'MediaRegion' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'NotificationsConfiguration' => [
    'SnsTopicArn' => '',
    'SqsQueueArn' => ''
  ]
]));

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

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

append(json_encode([
  'ClientRequestToken' => '',
  'ExternalMeetingId' => '',
  'MeetingHostId' => '',
  'MediaRegion' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'NotificationsConfiguration' => [
    'SnsTopicArn' => '',
    'SqsQueueArn' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/meetings');
$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}}/meetings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/meetings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  }
}'

import http.client

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

payload = "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/meetings"

payload = {
    "ClientRequestToken": "",
    "ExternalMeetingId": "",
    "MeetingHostId": "",
    "MediaRegion": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "NotificationsConfiguration": {
        "SnsTopicArn": "",
        "SqsQueueArn": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\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}}/meetings")

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  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\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/meetings') do |req|
  req.body = "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ClientRequestToken": "",
        "ExternalMeetingId": "",
        "MeetingHostId": "",
        "MediaRegion": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "NotificationsConfiguration": json!({
            "SnsTopicArn": "",
            "SqsQueueArn": ""
        })
    });

    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 '{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  }
}' |  \
  http POST {{baseUrl}}/meetings \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientRequestToken": "",\n  "ExternalMeetingId": "",\n  "MeetingHostId": "",\n  "MediaRegion": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "NotificationsConfiguration": {\n    "SnsTopicArn": "",\n    "SqsQueueArn": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/meetings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "NotificationsConfiguration": [
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/meetings")! 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}}/meetings/:meetingId/dial-outs");

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  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/meetings/:meetingId/dial-outs" {:content-type :json
                                                                          :form-params {:FromPhoneNumber ""
                                                                                        :ToPhoneNumber ""
                                                                                        :JoinToken ""}})

require "http/client"

url = "{{baseUrl}}/meetings/:meetingId/dial-outs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\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}}/meetings/:meetingId/dial-outs"),
    Content = new StringContent("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\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}}/meetings/:meetingId/dial-outs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/meetings/:meetingId/dial-outs"

	payload := strings.NewReader("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\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/meetings/:meetingId/dial-outs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "JoinToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/meetings/:meetingId/dial-outs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/meetings/:meetingId/dial-outs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\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  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/meetings/:meetingId/dial-outs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/meetings/:meetingId/dial-outs")
  .header("content-type", "application/json")
  .body("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FromPhoneNumber: '',
  ToPhoneNumber: '',
  JoinToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/meetings/:meetingId/dial-outs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings/:meetingId/dial-outs',
  headers: {'content-type': 'application/json'},
  data: {FromPhoneNumber: '', ToPhoneNumber: '', JoinToken: ''}
};

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

const url = '{{baseUrl}}/meetings/:meetingId/dial-outs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FromPhoneNumber":"","ToPhoneNumber":"","JoinToken":""}'
};

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}}/meetings/:meetingId/dial-outs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FromPhoneNumber": "",\n  "ToPhoneNumber": "",\n  "JoinToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/meetings/:meetingId/dial-outs")
  .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/meetings/:meetingId/dial-outs',
  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({FromPhoneNumber: '', ToPhoneNumber: '', JoinToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings/:meetingId/dial-outs',
  headers: {'content-type': 'application/json'},
  body: {FromPhoneNumber: '', ToPhoneNumber: '', JoinToken: ''},
  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}}/meetings/:meetingId/dial-outs');

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

req.type('json');
req.send({
  FromPhoneNumber: '',
  ToPhoneNumber: '',
  JoinToken: ''
});

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}}/meetings/:meetingId/dial-outs',
  headers: {'content-type': 'application/json'},
  data: {FromPhoneNumber: '', ToPhoneNumber: '', JoinToken: ''}
};

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

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

const url = '{{baseUrl}}/meetings/:meetingId/dial-outs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FromPhoneNumber":"","ToPhoneNumber":"","JoinToken":""}'
};

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 = @{ @"FromPhoneNumber": @"",
                              @"ToPhoneNumber": @"",
                              @"JoinToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/meetings/:meetingId/dial-outs"]
                                                       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}}/meetings/:meetingId/dial-outs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\n}" in

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

 "{{baseUrl}}/meetings/:meetingId/dial-outs",
  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([
    'FromPhoneNumber' => '',
    'ToPhoneNumber' => '',
    'JoinToken' => ''
  ]),
  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}}/meetings/:meetingId/dial-outs', [
  'body' => '{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "JoinToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/meetings/:meetingId/dial-outs');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FromPhoneNumber' => '',
  'ToPhoneNumber' => '',
  'JoinToken' => ''
]));

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

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

append(json_encode([
  'FromPhoneNumber' => '',
  'ToPhoneNumber' => '',
  'JoinToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/meetings/:meetingId/dial-outs');
$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}}/meetings/:meetingId/dial-outs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "JoinToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/meetings/:meetingId/dial-outs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "JoinToken": ""
}'

import http.client

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

payload = "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/meetings/:meetingId/dial-outs", payload, headers)

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

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

import requests

url = "{{baseUrl}}/meetings/:meetingId/dial-outs"

payload = {
    "FromPhoneNumber": "",
    "ToPhoneNumber": "",
    "JoinToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/meetings/:meetingId/dial-outs"

payload <- "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\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}}/meetings/:meetingId/dial-outs")

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  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\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/meetings/:meetingId/dial-outs') do |req|
  req.body = "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"JoinToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/meetings/:meetingId/dial-outs";

    let payload = json!({
        "FromPhoneNumber": "",
        "ToPhoneNumber": "",
        "JoinToken": ""
    });

    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 '{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "JoinToken": ""
}' |  \
  http POST {{baseUrl}}/meetings/:meetingId/dial-outs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "FromPhoneNumber": "",\n  "ToPhoneNumber": "",\n  "JoinToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/meetings/:meetingId/dial-outs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "JoinToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/meetings/:meetingId/dial-outs")! 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}}/meetings?operation=#operation=create-attendees");

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  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/meetings#operation=create-attendees" {:query-params {:operation ""}
                                                                                :content-type :json
                                                                                :form-params {:ClientRequestToken ""
                                                                                              :ExternalMeetingId ""
                                                                                              :MeetingHostId ""
                                                                                              :MediaRegion ""
                                                                                              :Tags [{:Key ""
                                                                                                      :Value ""}]
                                                                                              :NotificationsConfiguration {:SnsTopicArn ""
                                                                                                                           :SqsQueueArn ""}
                                                                                              :Attendees [{:ExternalUserId ""
                                                                                                           :Tags ""}]}})

require "http/client"

url = "{{baseUrl}}/meetings?operation=#operation=create-attendees"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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}}/meetings?operation=#operation=create-attendees"),
    Content = new StringContent("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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}}/meetings?operation=#operation=create-attendees");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/meetings?operation=#operation=create-attendees"

	payload := strings.NewReader("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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/meetings?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 328

{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  },
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/meetings?operation=#operation=create-attendees")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/meetings?operation=#operation=create-attendees"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/meetings?operation=#operation=create-attendees")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/meetings?operation=#operation=create-attendees")
  .header("content-type", "application/json")
  .body("{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  ClientRequestToken: '',
  ExternalMeetingId: '',
  MeetingHostId: '',
  MediaRegion: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  NotificationsConfiguration: {
    SnsTopicArn: '',
    SqsQueueArn: ''
  },
  Attendees: [
    {
      ExternalUserId: '',
      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}}/meetings?operation=#operation=create-attendees');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings#operation=create-attendees',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {
    ClientRequestToken: '',
    ExternalMeetingId: '',
    MeetingHostId: '',
    MediaRegion: '',
    Tags: [{Key: '', Value: ''}],
    NotificationsConfiguration: {SnsTopicArn: '', SqsQueueArn: ''},
    Attendees: [{ExternalUserId: '', Tags: ''}]
  }
};

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

const url = '{{baseUrl}}/meetings?operation=#operation=create-attendees';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ClientRequestToken":"","ExternalMeetingId":"","MeetingHostId":"","MediaRegion":"","Tags":[{"Key":"","Value":""}],"NotificationsConfiguration":{"SnsTopicArn":"","SqsQueueArn":""},"Attendees":[{"ExternalUserId":"","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}}/meetings?operation=#operation=create-attendees',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientRequestToken": "",\n  "ExternalMeetingId": "",\n  "MeetingHostId": "",\n  "MediaRegion": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "NotificationsConfiguration": {\n    "SnsTopicArn": "",\n    "SqsQueueArn": ""\n  },\n  "Attendees": [\n    {\n      "ExternalUserId": "",\n      "Tags": ""\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  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/meetings?operation=#operation=create-attendees")
  .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/meetings?operation=',
  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({
  ClientRequestToken: '',
  ExternalMeetingId: '',
  MeetingHostId: '',
  MediaRegion: '',
  Tags: [{Key: '', Value: ''}],
  NotificationsConfiguration: {SnsTopicArn: '', SqsQueueArn: ''},
  Attendees: [{ExternalUserId: '', Tags: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/meetings#operation=create-attendees',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {
    ClientRequestToken: '',
    ExternalMeetingId: '',
    MeetingHostId: '',
    MediaRegion: '',
    Tags: [{Key: '', Value: ''}],
    NotificationsConfiguration: {SnsTopicArn: '', SqsQueueArn: ''},
    Attendees: [{ExternalUserId: '', 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}}/meetings#operation=create-attendees');

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

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

req.type('json');
req.send({
  ClientRequestToken: '',
  ExternalMeetingId: '',
  MeetingHostId: '',
  MediaRegion: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  NotificationsConfiguration: {
    SnsTopicArn: '',
    SqsQueueArn: ''
  },
  Attendees: [
    {
      ExternalUserId: '',
      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}}/meetings#operation=create-attendees',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {
    ClientRequestToken: '',
    ExternalMeetingId: '',
    MeetingHostId: '',
    MediaRegion: '',
    Tags: [{Key: '', Value: ''}],
    NotificationsConfiguration: {SnsTopicArn: '', SqsQueueArn: ''},
    Attendees: [{ExternalUserId: '', Tags: ''}]
  }
};

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

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

const url = '{{baseUrl}}/meetings?operation=#operation=create-attendees';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ClientRequestToken":"","ExternalMeetingId":"","MeetingHostId":"","MediaRegion":"","Tags":[{"Key":"","Value":""}],"NotificationsConfiguration":{"SnsTopicArn":"","SqsQueueArn":""},"Attendees":[{"ExternalUserId":"","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 = @{ @"ClientRequestToken": @"",
                              @"ExternalMeetingId": @"",
                              @"MeetingHostId": @"",
                              @"MediaRegion": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"NotificationsConfiguration": @{ @"SnsTopicArn": @"", @"SqsQueueArn": @"" },
                              @"Attendees": @[ @{ @"ExternalUserId": @"", @"Tags": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/meetings?operation=#operation=create-attendees"]
                                                       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}}/meetings?operation=#operation=create-attendees" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/meetings?operation=#operation=create-attendees",
  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([
    'ClientRequestToken' => '',
    'ExternalMeetingId' => '',
    'MeetingHostId' => '',
    'MediaRegion' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'NotificationsConfiguration' => [
        'SnsTopicArn' => '',
        'SqsQueueArn' => ''
    ],
    'Attendees' => [
        [
                'ExternalUserId' => '',
                '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}}/meetings?operation=#operation=create-attendees', [
  'body' => '{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  },
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/meetings#operation=create-attendees');
$request->setMethod(HTTP_METH_POST);

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientRequestToken' => '',
  'ExternalMeetingId' => '',
  'MeetingHostId' => '',
  'MediaRegion' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'NotificationsConfiguration' => [
    'SnsTopicArn' => '',
    'SqsQueueArn' => ''
  ],
  'Attendees' => [
    [
        'ExternalUserId' => '',
        'Tags' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'ClientRequestToken' => '',
  'ExternalMeetingId' => '',
  'MeetingHostId' => '',
  'MediaRegion' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'NotificationsConfiguration' => [
    'SnsTopicArn' => '',
    'SqsQueueArn' => ''
  ],
  'Attendees' => [
    [
        'ExternalUserId' => '',
        'Tags' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/meetings#operation=create-attendees');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/meetings?operation=#operation=create-attendees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  },
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/meetings?operation=#operation=create-attendees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  },
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/meetings?operation=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/meetings#operation=create-attendees"

querystring = {"operation":""}

payload = {
    "ClientRequestToken": "",
    "ExternalMeetingId": "",
    "MeetingHostId": "",
    "MediaRegion": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "NotificationsConfiguration": {
        "SnsTopicArn": "",
        "SqsQueueArn": ""
    },
    "Attendees": [
        {
            "ExternalUserId": "",
            "Tags": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/meetings#operation=create-attendees"

queryString <- list(operation = "")

payload <- "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/meetings?operation=#operation=create-attendees")

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  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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/meetings') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"ClientRequestToken\": \"\",\n  \"ExternalMeetingId\": \"\",\n  \"MeetingHostId\": \"\",\n  \"MediaRegion\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NotificationsConfiguration\": {\n    \"SnsTopicArn\": \"\",\n    \"SqsQueueArn\": \"\"\n  },\n  \"Attendees\": [\n    {\n      \"ExternalUserId\": \"\",\n      \"Tags\": \"\"\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}}/meetings#operation=create-attendees";

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

    let payload = json!({
        "ClientRequestToken": "",
        "ExternalMeetingId": "",
        "MeetingHostId": "",
        "MediaRegion": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "NotificationsConfiguration": json!({
            "SnsTopicArn": "",
            "SqsQueueArn": ""
        }),
        "Attendees": (
            json!({
                "ExternalUserId": "",
                "Tags": ""
            })
        )
    });

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

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

    dbg!(results);
}

echo '{
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "NotificationsConfiguration": {
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  },
  "Attendees": [
    {
      "ExternalUserId": "",
      "Tags": ""
    }
  ]
}' |  \
  http POST '{{baseUrl}}/meetings?operation=#operation=create-attendees' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientRequestToken": "",\n  "ExternalMeetingId": "",\n  "MeetingHostId": "",\n  "MediaRegion": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "NotificationsConfiguration": {\n    "SnsTopicArn": "",\n    "SqsQueueArn": ""\n  },\n  "Attendees": [\n    {\n      "ExternalUserId": "",\n      "Tags": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/meetings?operation=#operation=create-attendees'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ClientRequestToken": "",
  "ExternalMeetingId": "",
  "MeetingHostId": "",
  "MediaRegion": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "NotificationsConfiguration": [
    "SnsTopicArn": "",
    "SqsQueueArn": ""
  ],
  "Attendees": [
    [
      "ExternalUserId": "",
      "Tags": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/meetings?operation=#operation=create-attendees")! 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}}/phone-number-orders");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/phone-number-orders" {:content-type :json
                                                                :form-params {:ProductType ""
                                                                              :E164PhoneNumbers []}})

require "http/client"

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

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"ProductType\": \"\",\n  \"E164PhoneNumbers\": []\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-orders HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "ProductType": "",
  "E164PhoneNumbers": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/phone-number-orders")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProductType\": \"\",\n  \"E164PhoneNumbers\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/phone-number-orders")
  .header("content-type", "application/json")
  .body("{\n  \"ProductType\": \"\",\n  \"E164PhoneNumbers\": []\n}")
  .asString();

const data = JSON.stringify({
  ProductType: '',
  E164PhoneNumbers: []
});

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-orders');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/phone-number-orders',
  headers: {'content-type': 'application/json'},
  data: {ProductType: '', E164PhoneNumbers: []}
};

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

const url = '{{baseUrl}}/phone-number-orders';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProductType":"","E164PhoneNumbers":[]}'
};

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-orders',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProductType": "",\n  "E164PhoneNumbers": []\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/phone-number-orders',
  headers: {'content-type': 'application/json'},
  body: {ProductType: '', E164PhoneNumbers: []},
  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-orders');

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

req.type('json');
req.send({
  ProductType: '',
  E164PhoneNumbers: []
});

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-orders',
  headers: {'content-type': 'application/json'},
  data: {ProductType: '', E164PhoneNumbers: []}
};

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-orders';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ProductType":"","E164PhoneNumbers":[]}'
};

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

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

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

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

 "{{baseUrl}}/phone-number-orders",
  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([
    'ProductType' => '',
    'E164PhoneNumbers' => [
        
    ]
  ]),
  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-orders', [
  'body' => '{
  "ProductType": "",
  "E164PhoneNumbers": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

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

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/phone-number-orders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProductType": "",
  "E164PhoneNumbers": []
}'

import http.client

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

payload = "{\n  \"ProductType\": \"\",\n  \"E164PhoneNumbers\": []\n}"

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

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

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

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

import requests

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

payload = {
    "ProductType": "",
    "E164PhoneNumbers": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"ProductType\": \"\",\n  \"E164PhoneNumbers\": []\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-orders")

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  \"ProductType\": \"\",\n  \"E164PhoneNumbers\": []\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-orders') do |req|
  req.body = "{\n  \"ProductType\": \"\",\n  \"E164PhoneNumbers\": []\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-orders";

    let payload = json!({
        "ProductType": "",
        "E164PhoneNumbers": ()
    });

    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 '{
  "ProductType": "",
  "E164PhoneNumbers": []
}' |  \
  http POST {{baseUrl}}/phone-number-orders \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProductType": "",\n  "E164PhoneNumbers": []\n}' \
  --output-document \
  - {{baseUrl}}/phone-number-orders

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/phone-number-orders")! 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}}/voice-connectors/:voiceConnectorId/proxy-sessions");

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  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions" {:content-type :json
                                                                                              :form-params {:ParticipantPhoneNumbers []
                                                                                                            :Name ""
                                                                                                            :ExpiryMinutes 0
                                                                                                            :Capabilities []
                                                                                                            :NumberSelectionBehavior ""
                                                                                                            :GeoMatchLevel ""
                                                                                                            :GeoMatchParams {:Country ""
                                                                                                                             :AreaCode ""}}})

require "http/client"

url = "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\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}}/voice-connectors/:voiceConnectorId/proxy-sessions"),
    Content = new StringContent("{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\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}}/voice-connectors/:voiceConnectorId/proxy-sessions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions"

	payload := strings.NewReader("{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\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/voice-connectors/:voiceConnectorId/proxy-sessions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 214

{
  "ParticipantPhoneNumbers": [],
  "Name": "",
  "ExpiryMinutes": 0,
  "Capabilities": [],
  "NumberSelectionBehavior": "",
  "GeoMatchLevel": "",
  "GeoMatchParams": {
    "Country": "",
    "AreaCode": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\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  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions")
  .header("content-type", "application/json")
  .body("{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  ParticipantPhoneNumbers: [],
  Name: '',
  ExpiryMinutes: 0,
  Capabilities: [],
  NumberSelectionBehavior: '',
  GeoMatchLevel: '',
  GeoMatchParams: {
    Country: '',
    AreaCode: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions',
  headers: {'content-type': 'application/json'},
  data: {
    ParticipantPhoneNumbers: [],
    Name: '',
    ExpiryMinutes: 0,
    Capabilities: [],
    NumberSelectionBehavior: '',
    GeoMatchLevel: '',
    GeoMatchParams: {Country: '', AreaCode: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ParticipantPhoneNumbers":[],"Name":"","ExpiryMinutes":0,"Capabilities":[],"NumberSelectionBehavior":"","GeoMatchLevel":"","GeoMatchParams":{"Country":"","AreaCode":""}}'
};

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}}/voice-connectors/:voiceConnectorId/proxy-sessions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ParticipantPhoneNumbers": [],\n  "Name": "",\n  "ExpiryMinutes": 0,\n  "Capabilities": [],\n  "NumberSelectionBehavior": "",\n  "GeoMatchLevel": "",\n  "GeoMatchParams": {\n    "Country": "",\n    "AreaCode": ""\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  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions")
  .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/voice-connectors/:voiceConnectorId/proxy-sessions',
  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({
  ParticipantPhoneNumbers: [],
  Name: '',
  ExpiryMinutes: 0,
  Capabilities: [],
  NumberSelectionBehavior: '',
  GeoMatchLevel: '',
  GeoMatchParams: {Country: '', AreaCode: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions',
  headers: {'content-type': 'application/json'},
  body: {
    ParticipantPhoneNumbers: [],
    Name: '',
    ExpiryMinutes: 0,
    Capabilities: [],
    NumberSelectionBehavior: '',
    GeoMatchLevel: '',
    GeoMatchParams: {Country: '', AreaCode: ''}
  },
  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}}/voice-connectors/:voiceConnectorId/proxy-sessions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ParticipantPhoneNumbers: [],
  Name: '',
  ExpiryMinutes: 0,
  Capabilities: [],
  NumberSelectionBehavior: '',
  GeoMatchLevel: '',
  GeoMatchParams: {
    Country: '',
    AreaCode: ''
  }
});

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}}/voice-connectors/:voiceConnectorId/proxy-sessions',
  headers: {'content-type': 'application/json'},
  data: {
    ParticipantPhoneNumbers: [],
    Name: '',
    ExpiryMinutes: 0,
    Capabilities: [],
    NumberSelectionBehavior: '',
    GeoMatchLevel: '',
    GeoMatchParams: {Country: '', AreaCode: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ParticipantPhoneNumbers":[],"Name":"","ExpiryMinutes":0,"Capabilities":[],"NumberSelectionBehavior":"","GeoMatchLevel":"","GeoMatchParams":{"Country":"","AreaCode":""}}'
};

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 = @{ @"ParticipantPhoneNumbers": @[  ],
                              @"Name": @"",
                              @"ExpiryMinutes": @0,
                              @"Capabilities": @[  ],
                              @"NumberSelectionBehavior": @"",
                              @"GeoMatchLevel": @"",
                              @"GeoMatchParams": @{ @"Country": @"", @"AreaCode": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions"]
                                                       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}}/voice-connectors/:voiceConnectorId/proxy-sessions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions",
  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([
    'ParticipantPhoneNumbers' => [
        
    ],
    'Name' => '',
    'ExpiryMinutes' => 0,
    'Capabilities' => [
        
    ],
    'NumberSelectionBehavior' => '',
    'GeoMatchLevel' => '',
    'GeoMatchParams' => [
        'Country' => '',
        'AreaCode' => ''
    ]
  ]),
  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}}/voice-connectors/:voiceConnectorId/proxy-sessions', [
  'body' => '{
  "ParticipantPhoneNumbers": [],
  "Name": "",
  "ExpiryMinutes": 0,
  "Capabilities": [],
  "NumberSelectionBehavior": "",
  "GeoMatchLevel": "",
  "GeoMatchParams": {
    "Country": "",
    "AreaCode": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ParticipantPhoneNumbers' => [
    
  ],
  'Name' => '',
  'ExpiryMinutes' => 0,
  'Capabilities' => [
    
  ],
  'NumberSelectionBehavior' => '',
  'GeoMatchLevel' => '',
  'GeoMatchParams' => [
    'Country' => '',
    'AreaCode' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ParticipantPhoneNumbers' => [
    
  ],
  'Name' => '',
  'ExpiryMinutes' => 0,
  'Capabilities' => [
    
  ],
  'NumberSelectionBehavior' => '',
  'GeoMatchLevel' => '',
  'GeoMatchParams' => [
    'Country' => '',
    'AreaCode' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions');
$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}}/voice-connectors/:voiceConnectorId/proxy-sessions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ParticipantPhoneNumbers": [],
  "Name": "",
  "ExpiryMinutes": 0,
  "Capabilities": [],
  "NumberSelectionBehavior": "",
  "GeoMatchLevel": "",
  "GeoMatchParams": {
    "Country": "",
    "AreaCode": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ParticipantPhoneNumbers": [],
  "Name": "",
  "ExpiryMinutes": 0,
  "Capabilities": [],
  "NumberSelectionBehavior": "",
  "GeoMatchLevel": "",
  "GeoMatchParams": {
    "Country": "",
    "AreaCode": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/voice-connectors/:voiceConnectorId/proxy-sessions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions"

payload = {
    "ParticipantPhoneNumbers": [],
    "Name": "",
    "ExpiryMinutes": 0,
    "Capabilities": [],
    "NumberSelectionBehavior": "",
    "GeoMatchLevel": "",
    "GeoMatchParams": {
        "Country": "",
        "AreaCode": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions"

payload <- "{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\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}}/voice-connectors/:voiceConnectorId/proxy-sessions")

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  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\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/voice-connectors/:voiceConnectorId/proxy-sessions') do |req|
  req.body = "{\n  \"ParticipantPhoneNumbers\": [],\n  \"Name\": \"\",\n  \"ExpiryMinutes\": 0,\n  \"Capabilities\": [],\n  \"NumberSelectionBehavior\": \"\",\n  \"GeoMatchLevel\": \"\",\n  \"GeoMatchParams\": {\n    \"Country\": \"\",\n    \"AreaCode\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions";

    let payload = json!({
        "ParticipantPhoneNumbers": (),
        "Name": "",
        "ExpiryMinutes": 0,
        "Capabilities": (),
        "NumberSelectionBehavior": "",
        "GeoMatchLevel": "",
        "GeoMatchParams": json!({
            "Country": "",
            "AreaCode": ""
        })
    });

    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 '{
  "ParticipantPhoneNumbers": [],
  "Name": "",
  "ExpiryMinutes": 0,
  "Capabilities": [],
  "NumberSelectionBehavior": "",
  "GeoMatchLevel": "",
  "GeoMatchParams": {
    "Country": "",
    "AreaCode": ""
  }
}' |  \
  http POST {{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ParticipantPhoneNumbers": [],\n  "Name": "",\n  "ExpiryMinutes": 0,\n  "Capabilities": [],\n  "NumberSelectionBehavior": "",\n  "GeoMatchLevel": "",\n  "GeoMatchParams": {\n    "Country": "",\n    "AreaCode": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ParticipantPhoneNumbers": [],
  "Name": "",
  "ExpiryMinutes": 0,
  "Capabilities": [],
  "NumberSelectionBehavior": "",
  "GeoMatchLevel": "",
  "GeoMatchParams": [
    "Country": "",
    "AreaCode": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions")! 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}}/accounts/:accountId/rooms");

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  \"ClientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:accountId/rooms" {:content-type :json
                                                                      :form-params {:Name ""
                                                                                    :ClientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/rooms"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\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}}/accounts/:accountId/rooms"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\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}}/accounts/:accountId/rooms");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:accountId/rooms"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\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/accounts/:accountId/rooms HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "Name": "",
  "ClientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId/rooms")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/rooms"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\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  \"ClientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/rooms")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId/rooms")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  ClientRequestToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:accountId/rooms');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/rooms',
  headers: {'content-type': 'application/json'},
  data: {Name: '', ClientRequestToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:accountId/rooms';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","ClientRequestToken":""}'
};

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}}/accounts/:accountId/rooms',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "ClientRequestToken": ""\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  \"ClientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/rooms")
  .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/accounts/:accountId/rooms',
  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: '', ClientRequestToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/rooms',
  headers: {'content-type': 'application/json'},
  body: {Name: '', ClientRequestToken: ''},
  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}}/accounts/:accountId/rooms');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  ClientRequestToken: ''
});

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}}/accounts/:accountId/rooms',
  headers: {'content-type': 'application/json'},
  data: {Name: '', ClientRequestToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:accountId/rooms';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","ClientRequestToken":""}'
};

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": @"",
                              @"ClientRequestToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/rooms"]
                                                       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}}/accounts/:accountId/rooms" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId/rooms",
  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' => '',
    'ClientRequestToken' => ''
  ]),
  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}}/accounts/:accountId/rooms', [
  'body' => '{
  "Name": "",
  "ClientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/rooms');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'ClientRequestToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'ClientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId/rooms');
$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}}/accounts/:accountId/rooms' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ClientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/rooms' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ClientRequestToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:accountId/rooms", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId/rooms"

payload = {
    "Name": "",
    "ClientRequestToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/rooms"

payload <- "{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\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}}/accounts/:accountId/rooms")

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  \"ClientRequestToken\": \"\"\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/accounts/:accountId/rooms') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"ClientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/rooms";

    let payload = json!({
        "Name": "",
        "ClientRequestToken": ""
    });

    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": "",
  "ClientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/accounts/:accountId/rooms \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "ClientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/rooms

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "ClientRequestToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/rooms")! 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}}/accounts/:accountId/rooms/:roomId/memberships");

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  \"MemberId\": \"\",\n  \"Role\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships" {:content-type :json
                                                                                          :form-params {:MemberId ""
                                                                                                        :Role ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\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}}/accounts/:accountId/rooms/:roomId/memberships"),
    Content = new StringContent("{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\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}}/accounts/:accountId/rooms/:roomId/memberships");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships"

	payload := strings.NewReader("{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\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/accounts/:accountId/rooms/:roomId/memberships HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "MemberId": "",
  "Role": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\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  \"MemberId\": \"\",\n  \"Role\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships")
  .header("content-type", "application/json")
  .body("{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MemberId: '',
  Role: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships',
  headers: {'content-type': 'application/json'},
  data: {MemberId: '', Role: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MemberId":"","Role":""}'
};

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}}/accounts/:accountId/rooms/:roomId/memberships',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MemberId": "",\n  "Role": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships")
  .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/accounts/:accountId/rooms/:roomId/memberships',
  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({MemberId: '', Role: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships',
  headers: {'content-type': 'application/json'},
  body: {MemberId: '', Role: ''},
  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}}/accounts/:accountId/rooms/:roomId/memberships');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  MemberId: '',
  Role: ''
});

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}}/accounts/:accountId/rooms/:roomId/memberships',
  headers: {'content-type': 'application/json'},
  data: {MemberId: '', Role: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"MemberId":"","Role":""}'
};

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 = @{ @"MemberId": @"",
                              @"Role": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships"]
                                                       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}}/accounts/:accountId/rooms/:roomId/memberships" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships",
  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([
    'MemberId' => '',
    'Role' => ''
  ]),
  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}}/accounts/:accountId/rooms/:roomId/memberships', [
  'body' => '{
  "MemberId": "",
  "Role": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MemberId' => '',
  'Role' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'MemberId' => '',
  'Role' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships');
$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}}/accounts/:accountId/rooms/:roomId/memberships' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MemberId": "",
  "Role": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MemberId": "",
  "Role": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:accountId/rooms/:roomId/memberships", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships"

payload = {
    "MemberId": "",
    "Role": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships"

payload <- "{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\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}}/accounts/:accountId/rooms/:roomId/memberships")

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  \"MemberId\": \"\",\n  \"Role\": \"\"\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/accounts/:accountId/rooms/:roomId/memberships') do |req|
  req.body = "{\n  \"MemberId\": \"\",\n  \"Role\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships";

    let payload = json!({
        "MemberId": "",
        "Role": ""
    });

    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 '{
  "MemberId": "",
  "Role": ""
}' |  \
  http POST {{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "MemberId": "",\n  "Role": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "MemberId": "",
  "Role": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/rooms/:roomId/memberships")! 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}}/sip-media-applications");

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  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/sip-media-applications" {:content-type :json
                                                                   :form-params {:AwsRegion ""
                                                                                 :Name ""
                                                                                 :Endpoints [{:LambdaArn ""}]}})

require "http/client"

url = "{{baseUrl}}/sip-media-applications"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\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}}/sip-media-applications"),
    Content = new StringContent("{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\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}}/sip-media-applications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/sip-media-applications"

	payload := strings.NewReader("{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\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/sip-media-applications HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "AwsRegion": "",
  "Name": "",
  "Endpoints": [
    {
      "LambdaArn": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/sip-media-applications")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sip-media-applications"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\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  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/sip-media-applications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/sip-media-applications")
  .header("content-type", "application/json")
  .body("{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  AwsRegion: '',
  Name: '',
  Endpoints: [
    {
      LambdaArn: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/sip-media-applications');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sip-media-applications',
  headers: {'content-type': 'application/json'},
  data: {AwsRegion: '', Name: '', Endpoints: [{LambdaArn: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/sip-media-applications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AwsRegion":"","Name":"","Endpoints":[{"LambdaArn":""}]}'
};

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}}/sip-media-applications',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AwsRegion": "",\n  "Name": "",\n  "Endpoints": [\n    {\n      "LambdaArn": ""\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  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/sip-media-applications")
  .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/sip-media-applications',
  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({AwsRegion: '', Name: '', Endpoints: [{LambdaArn: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sip-media-applications',
  headers: {'content-type': 'application/json'},
  body: {AwsRegion: '', Name: '', Endpoints: [{LambdaArn: ''}]},
  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}}/sip-media-applications');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AwsRegion: '',
  Name: '',
  Endpoints: [
    {
      LambdaArn: ''
    }
  ]
});

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}}/sip-media-applications',
  headers: {'content-type': 'application/json'},
  data: {AwsRegion: '', Name: '', Endpoints: [{LambdaArn: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/sip-media-applications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AwsRegion":"","Name":"","Endpoints":[{"LambdaArn":""}]}'
};

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 = @{ @"AwsRegion": @"",
                              @"Name": @"",
                              @"Endpoints": @[ @{ @"LambdaArn": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/sip-media-applications"]
                                                       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}}/sip-media-applications" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/sip-media-applications",
  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([
    'AwsRegion' => '',
    'Name' => '',
    'Endpoints' => [
        [
                'LambdaArn' => ''
        ]
    ]
  ]),
  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}}/sip-media-applications', [
  'body' => '{
  "AwsRegion": "",
  "Name": "",
  "Endpoints": [
    {
      "LambdaArn": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/sip-media-applications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AwsRegion' => '',
  'Name' => '',
  'Endpoints' => [
    [
        'LambdaArn' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AwsRegion' => '',
  'Name' => '',
  'Endpoints' => [
    [
        'LambdaArn' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/sip-media-applications');
$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}}/sip-media-applications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AwsRegion": "",
  "Name": "",
  "Endpoints": [
    {
      "LambdaArn": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/sip-media-applications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AwsRegion": "",
  "Name": "",
  "Endpoints": [
    {
      "LambdaArn": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/sip-media-applications", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/sip-media-applications"

payload = {
    "AwsRegion": "",
    "Name": "",
    "Endpoints": [{ "LambdaArn": "" }]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sip-media-applications"

payload <- "{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\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}}/sip-media-applications")

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  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\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/sip-media-applications') do |req|
  req.body = "{\n  \"AwsRegion\": \"\",\n  \"Name\": \"\",\n  \"Endpoints\": [\n    {\n      \"LambdaArn\": \"\"\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}}/sip-media-applications";

    let payload = json!({
        "AwsRegion": "",
        "Name": "",
        "Endpoints": (json!({"LambdaArn": ""}))
    });

    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 '{
  "AwsRegion": "",
  "Name": "",
  "Endpoints": [
    {
      "LambdaArn": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/sip-media-applications \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AwsRegion": "",\n  "Name": "",\n  "Endpoints": [\n    {\n      "LambdaArn": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/sip-media-applications

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AwsRegion": "",
  "Name": "",
  "Endpoints": [["LambdaArn": ""]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sip-media-applications")! 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}}/sip-media-applications/:sipMediaApplicationId/calls");

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  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls" {:content-type :json
                                                                                                :form-params {:FromPhoneNumber ""
                                                                                                              :ToPhoneNumber ""
                                                                                                              :SipHeaders {}}})

require "http/client"

url = "{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\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}}/sip-media-applications/:sipMediaApplicationId/calls"),
    Content = new StringContent("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\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}}/sip-media-applications/:sipMediaApplicationId/calls");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls"

	payload := strings.NewReader("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\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/sip-media-applications/:sipMediaApplicationId/calls HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "SipHeaders": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\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  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls")
  .header("content-type", "application/json")
  .body("{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\n}")
  .asString();

const data = JSON.stringify({
  FromPhoneNumber: '',
  ToPhoneNumber: '',
  SipHeaders: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls',
  headers: {'content-type': 'application/json'},
  data: {FromPhoneNumber: '', ToPhoneNumber: '', SipHeaders: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FromPhoneNumber":"","ToPhoneNumber":"","SipHeaders":{}}'
};

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}}/sip-media-applications/:sipMediaApplicationId/calls',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FromPhoneNumber": "",\n  "ToPhoneNumber": "",\n  "SipHeaders": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls")
  .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/sip-media-applications/:sipMediaApplicationId/calls',
  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({FromPhoneNumber: '', ToPhoneNumber: '', SipHeaders: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls',
  headers: {'content-type': 'application/json'},
  body: {FromPhoneNumber: '', ToPhoneNumber: '', SipHeaders: {}},
  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}}/sip-media-applications/:sipMediaApplicationId/calls');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FromPhoneNumber: '',
  ToPhoneNumber: '',
  SipHeaders: {}
});

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}}/sip-media-applications/:sipMediaApplicationId/calls',
  headers: {'content-type': 'application/json'},
  data: {FromPhoneNumber: '', ToPhoneNumber: '', SipHeaders: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FromPhoneNumber":"","ToPhoneNumber":"","SipHeaders":{}}'
};

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 = @{ @"FromPhoneNumber": @"",
                              @"ToPhoneNumber": @"",
                              @"SipHeaders": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls"]
                                                       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}}/sip-media-applications/:sipMediaApplicationId/calls" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls",
  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([
    'FromPhoneNumber' => '',
    'ToPhoneNumber' => '',
    'SipHeaders' => [
        
    ]
  ]),
  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}}/sip-media-applications/:sipMediaApplicationId/calls', [
  'body' => '{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "SipHeaders": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FromPhoneNumber' => '',
  'ToPhoneNumber' => '',
  'SipHeaders' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FromPhoneNumber' => '',
  'ToPhoneNumber' => '',
  'SipHeaders' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls');
$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}}/sip-media-applications/:sipMediaApplicationId/calls' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "SipHeaders": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "SipHeaders": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/sip-media-applications/:sipMediaApplicationId/calls", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls"

payload = {
    "FromPhoneNumber": "",
    "ToPhoneNumber": "",
    "SipHeaders": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls"

payload <- "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\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}}/sip-media-applications/:sipMediaApplicationId/calls")

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  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\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/sip-media-applications/:sipMediaApplicationId/calls') do |req|
  req.body = "{\n  \"FromPhoneNumber\": \"\",\n  \"ToPhoneNumber\": \"\",\n  \"SipHeaders\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls";

    let payload = json!({
        "FromPhoneNumber": "",
        "ToPhoneNumber": "",
        "SipHeaders": 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 '{
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "SipHeaders": {}
}' |  \
  http POST {{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "FromPhoneNumber": "",\n  "ToPhoneNumber": "",\n  "SipHeaders": {}\n}' \
  --output-document \
  - {{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "FromPhoneNumber": "",
  "ToPhoneNumber": "",
  "SipHeaders": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sip-media-applications/:sipMediaApplicationId/calls")! 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}}/sip-rules");

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  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/sip-rules" {:content-type :json
                                                      :form-params {:Name ""
                                                                    :TriggerType ""
                                                                    :TriggerValue ""
                                                                    :Disabled false
                                                                    :TargetApplications [{:SipMediaApplicationId ""
                                                                                          :Priority ""
                                                                                          :AwsRegion ""}]}})

require "http/client"

url = "{{baseUrl}}/sip-rules"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\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}}/sip-rules"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\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}}/sip-rules");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/sip-rules"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\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/sip-rules HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 202

{
  "Name": "",
  "TriggerType": "",
  "TriggerValue": "",
  "Disabled": false,
  "TargetApplications": [
    {
      "SipMediaApplicationId": "",
      "Priority": "",
      "AwsRegion": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/sip-rules")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sip-rules"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\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  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/sip-rules")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/sip-rules")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  TriggerType: '',
  TriggerValue: '',
  Disabled: false,
  TargetApplications: [
    {
      SipMediaApplicationId: '',
      Priority: '',
      AwsRegion: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/sip-rules');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sip-rules',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    TriggerType: '',
    TriggerValue: '',
    Disabled: false,
    TargetApplications: [{SipMediaApplicationId: '', Priority: '', AwsRegion: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/sip-rules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","TriggerType":"","TriggerValue":"","Disabled":false,"TargetApplications":[{"SipMediaApplicationId":"","Priority":"","AwsRegion":""}]}'
};

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}}/sip-rules',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "TriggerType": "",\n  "TriggerValue": "",\n  "Disabled": false,\n  "TargetApplications": [\n    {\n      "SipMediaApplicationId": "",\n      "Priority": "",\n      "AwsRegion": ""\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  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/sip-rules")
  .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/sip-rules',
  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: '',
  TriggerType: '',
  TriggerValue: '',
  Disabled: false,
  TargetApplications: [{SipMediaApplicationId: '', Priority: '', AwsRegion: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sip-rules',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    TriggerType: '',
    TriggerValue: '',
    Disabled: false,
    TargetApplications: [{SipMediaApplicationId: '', Priority: '', AwsRegion: ''}]
  },
  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}}/sip-rules');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  TriggerType: '',
  TriggerValue: '',
  Disabled: false,
  TargetApplications: [
    {
      SipMediaApplicationId: '',
      Priority: '',
      AwsRegion: ''
    }
  ]
});

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}}/sip-rules',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    TriggerType: '',
    TriggerValue: '',
    Disabled: false,
    TargetApplications: [{SipMediaApplicationId: '', Priority: '', AwsRegion: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/sip-rules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","TriggerType":"","TriggerValue":"","Disabled":false,"TargetApplications":[{"SipMediaApplicationId":"","Priority":"","AwsRegion":""}]}'
};

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": @"",
                              @"TriggerType": @"",
                              @"TriggerValue": @"",
                              @"Disabled": @NO,
                              @"TargetApplications": @[ @{ @"SipMediaApplicationId": @"", @"Priority": @"", @"AwsRegion": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/sip-rules"]
                                                       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}}/sip-rules" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/sip-rules",
  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' => '',
    'TriggerType' => '',
    'TriggerValue' => '',
    'Disabled' => null,
    'TargetApplications' => [
        [
                'SipMediaApplicationId' => '',
                'Priority' => '',
                'AwsRegion' => ''
        ]
    ]
  ]),
  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}}/sip-rules', [
  'body' => '{
  "Name": "",
  "TriggerType": "",
  "TriggerValue": "",
  "Disabled": false,
  "TargetApplications": [
    {
      "SipMediaApplicationId": "",
      "Priority": "",
      "AwsRegion": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/sip-rules');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'TriggerType' => '',
  'TriggerValue' => '',
  'Disabled' => null,
  'TargetApplications' => [
    [
        'SipMediaApplicationId' => '',
        'Priority' => '',
        'AwsRegion' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'TriggerType' => '',
  'TriggerValue' => '',
  'Disabled' => null,
  'TargetApplications' => [
    [
        'SipMediaApplicationId' => '',
        'Priority' => '',
        'AwsRegion' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/sip-rules');
$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}}/sip-rules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "TriggerType": "",
  "TriggerValue": "",
  "Disabled": false,
  "TargetApplications": [
    {
      "SipMediaApplicationId": "",
      "Priority": "",
      "AwsRegion": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/sip-rules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "TriggerType": "",
  "TriggerValue": "",
  "Disabled": false,
  "TargetApplications": [
    {
      "SipMediaApplicationId": "",
      "Priority": "",
      "AwsRegion": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/sip-rules", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/sip-rules"

payload = {
    "Name": "",
    "TriggerType": "",
    "TriggerValue": "",
    "Disabled": False,
    "TargetApplications": [
        {
            "SipMediaApplicationId": "",
            "Priority": "",
            "AwsRegion": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sip-rules"

payload <- "{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\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}}/sip-rules")

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  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\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/sip-rules') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"TriggerType\": \"\",\n  \"TriggerValue\": \"\",\n  \"Disabled\": false,\n  \"TargetApplications\": [\n    {\n      \"SipMediaApplicationId\": \"\",\n      \"Priority\": \"\",\n      \"AwsRegion\": \"\"\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}}/sip-rules";

    let payload = json!({
        "Name": "",
        "TriggerType": "",
        "TriggerValue": "",
        "Disabled": false,
        "TargetApplications": (
            json!({
                "SipMediaApplicationId": "",
                "Priority": "",
                "AwsRegion": ""
            })
        )
    });

    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": "",
  "TriggerType": "",
  "TriggerValue": "",
  "Disabled": false,
  "TargetApplications": [
    {
      "SipMediaApplicationId": "",
      "Priority": "",
      "AwsRegion": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/sip-rules \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "TriggerType": "",\n  "TriggerValue": "",\n  "Disabled": false,\n  "TargetApplications": [\n    {\n      "SipMediaApplicationId": "",\n      "Priority": "",\n      "AwsRegion": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/sip-rules

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "TriggerType": "",
  "TriggerValue": "",
  "Disabled": false,
  "TargetApplications": [
    [
      "SipMediaApplicationId": "",
      "Priority": "",
      "AwsRegion": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sip-rules")! 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}}/accounts/:accountId/users?operation=#operation=create");

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  \"Email\": \"\",\n  \"UserType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:accountId/users#operation=create" {:query-params {:operation ""}
                                                                                       :content-type :json
                                                                                       :form-params {:Username ""
                                                                                                     :Email ""
                                                                                                     :UserType ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/users?operation=#operation=create"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\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}}/accounts/:accountId/users?operation=#operation=create"),
    Content = new StringContent("{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\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}}/accounts/:accountId/users?operation=#operation=create");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:accountId/users?operation=#operation=create"

	payload := strings.NewReader("{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\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/accounts/:accountId/users?operation= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "Username": "",
  "Email": "",
  "UserType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:accountId/users?operation=#operation=create")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/users?operation=#operation=create"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\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  \"Email\": \"\",\n  \"UserType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users?operation=#operation=create")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:accountId/users?operation=#operation=create")
  .header("content-type", "application/json")
  .body("{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Username: '',
  Email: '',
  UserType: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:accountId/users?operation=#operation=create');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users#operation=create',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {Username: '', Email: '', UserType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:accountId/users?operation=#operation=create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Username":"","Email":"","UserType":""}'
};

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}}/accounts/:accountId/users?operation=#operation=create',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Username": "",\n  "Email": "",\n  "UserType": ""\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  \"Email\": \"\",\n  \"UserType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/users?operation=#operation=create")
  .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/accounts/:accountId/users?operation=',
  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: '', Email: '', UserType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:accountId/users#operation=create',
  qs: {operation: ''},
  headers: {'content-type': 'application/json'},
  body: {Username: '', Email: '', UserType: ''},
  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}}/accounts/:accountId/users#operation=create');

req.query({
  operation: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Username: '',
  Email: '',
  UserType: ''
});

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}}/accounts/:accountId/users#operation=create',
  params: {operation: ''},
  headers: {'content-type': 'application/json'},
  data: {Username: '', Email: '', UserType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:accountId/users?operation=#operation=create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Username":"","Email":"","UserType":""}'
};

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": @"",
                              @"Email": @"",
                              @"UserType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:accountId/users?operation=#operation=create"]
                                                       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}}/accounts/:accountId/users?operation=#operation=create" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId/users?operation=#operation=create",
  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([
    'Username' => '',
    'Email' => '',
    'UserType' => ''
  ]),
  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}}/accounts/:accountId/users?operation=#operation=create', [
  'body' => '{
  "Username": "",
  "Email": "",
  "UserType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/users#operation=create');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'operation' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Username' => '',
  'Email' => '',
  'UserType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Username' => '',
  'Email' => '',
  'UserType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:accountId/users#operation=create');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'operation' => ''
]));

$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}}/accounts/:accountId/users?operation=#operation=create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Username": "",
  "Email": "",
  "UserType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/users?operation=#operation=create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Username": "",
  "Email": "",
  "UserType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:accountId/users?operation=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId/users#operation=create"

querystring = {"operation":""}

payload = {
    "Username": "",
    "Email": "",
    "UserType": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/users#operation=create"

queryString <- list(operation = "")

payload <- "{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/users?operation=#operation=create")

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  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\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/accounts/:accountId/users') do |req|
  req.params['operation'] = ''
  req.body = "{\n  \"Username\": \"\",\n  \"Email\": \"\",\n  \"UserType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/users#operation=create";

    let querystring = [
        ("operation", ""),
    ];

    let payload = json!({
        "Username": "",
        "Email": "",
        "UserType": ""
    });

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Username": "",
  "Email": "",
  "UserType": ""
}' |  \
  http POST '{{baseUrl}}/accounts/:accountId/users?operation=#operation=create' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Username": "",\n  "Email": "",\n  "UserType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/accounts/:accountId/users?operation=#operation=create'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Username": "",
  "Email": "",
  "UserType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/users?operation=#operation=create")! 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}}/voice-connectors");

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  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/voice-connectors" {:content-type :json
                                                             :form-params {:Name ""
                                                                           :AwsRegion ""
                                                                           :RequireEncryption false}})

require "http/client"

url = "{{baseUrl}}/voice-connectors"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\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}}/voice-connectors"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": 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}}/voice-connectors");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/voice-connectors"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\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/voice-connectors HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 65

{
  "Name": "",
  "AwsRegion": "",
  "RequireEncryption": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/voice-connectors")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/voice-connectors"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": 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  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/voice-connectors")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/voice-connectors")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  AwsRegion: '',
  RequireEncryption: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/voice-connectors');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connectors',
  headers: {'content-type': 'application/json'},
  data: {Name: '', AwsRegion: '', RequireEncryption: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/voice-connectors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","AwsRegion":"","RequireEncryption":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}}/voice-connectors',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "AwsRegion": "",\n  "RequireEncryption": 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  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/voice-connectors")
  .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/voice-connectors',
  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: '', AwsRegion: '', RequireEncryption: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connectors',
  headers: {'content-type': 'application/json'},
  body: {Name: '', AwsRegion: '', RequireEncryption: 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('POST', '{{baseUrl}}/voice-connectors');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  AwsRegion: '',
  RequireEncryption: 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: 'POST',
  url: '{{baseUrl}}/voice-connectors',
  headers: {'content-type': 'application/json'},
  data: {Name: '', AwsRegion: '', RequireEncryption: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/voice-connectors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","AwsRegion":"","RequireEncryption":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 = @{ @"Name": @"",
                              @"AwsRegion": @"",
                              @"RequireEncryption": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/voice-connectors"]
                                                       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}}/voice-connectors" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/voice-connectors",
  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' => '',
    'AwsRegion' => '',
    'RequireEncryption' => 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('POST', '{{baseUrl}}/voice-connectors', [
  'body' => '{
  "Name": "",
  "AwsRegion": "",
  "RequireEncryption": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/voice-connectors');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'AwsRegion' => '',
  'RequireEncryption' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'AwsRegion' => '',
  'RequireEncryption' => null
]));
$request->setRequestUrl('{{baseUrl}}/voice-connectors');
$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}}/voice-connectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "AwsRegion": "",
  "RequireEncryption": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/voice-connectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "AwsRegion": "",
  "RequireEncryption": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/voice-connectors", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/voice-connectors"

payload = {
    "Name": "",
    "AwsRegion": "",
    "RequireEncryption": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/voice-connectors"

payload <- "{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\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}}/voice-connectors")

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  \"AwsRegion\": \"\",\n  \"RequireEncryption\": 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.post('/baseUrl/voice-connectors') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"AwsRegion\": \"\",\n  \"RequireEncryption\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/voice-connectors";

    let payload = json!({
        "Name": "",
        "AwsRegion": "",
        "RequireEncryption": false
    });

    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": "",
  "AwsRegion": "",
  "RequireEncryption": false
}' |  \
  http POST {{baseUrl}}/voice-connectors \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "AwsRegion": "",\n  "RequireEncryption": false\n}' \
  --output-document \
  - {{baseUrl}}/voice-connectors

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "AwsRegion": "",
  "RequireEncryption": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/voice-connectors")! 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}}/voice-connector-groups");

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  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/voice-connector-groups" {:content-type :json
                                                                   :form-params {:Name ""
                                                                                 :VoiceConnectorItems [{:VoiceConnectorId ""
                                                                                                        :Priority ""}]}})

require "http/client"

url = "{{baseUrl}}/voice-connector-groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\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}}/voice-connector-groups"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\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}}/voice-connector-groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/voice-connector-groups"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\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/voice-connector-groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 111

{
  "Name": "",
  "VoiceConnectorItems": [
    {
      "VoiceConnectorId": "",
      "Priority": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/voice-connector-groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/voice-connector-groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\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  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/voice-connector-groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/voice-connector-groups")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  VoiceConnectorItems: [
    {
      VoiceConnectorId: '',
      Priority: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/voice-connector-groups');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connector-groups',
  headers: {'content-type': 'application/json'},
  data: {Name: '', VoiceConnectorItems: [{VoiceConnectorId: '', Priority: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/voice-connector-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","VoiceConnectorItems":[{"VoiceConnectorId":"","Priority":""}]}'
};

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}}/voice-connector-groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "VoiceConnectorItems": [\n    {\n      "VoiceConnectorId": "",\n      "Priority": ""\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  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/voice-connector-groups")
  .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/voice-connector-groups',
  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: '', VoiceConnectorItems: [{VoiceConnectorId: '', Priority: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/voice-connector-groups',
  headers: {'content-type': 'application/json'},
  body: {Name: '', VoiceConnectorItems: [{VoiceConnectorId: '', Priority: ''}]},
  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}}/voice-connector-groups');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  VoiceConnectorItems: [
    {
      VoiceConnectorId: '',
      Priority: ''
    }
  ]
});

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}}/voice-connector-groups',
  headers: {'content-type': 'application/json'},
  data: {Name: '', VoiceConnectorItems: [{VoiceConnectorId: '', Priority: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/voice-connector-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","VoiceConnectorItems":[{"VoiceConnectorId":"","Priority":""}]}'
};

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": @"",
                              @"VoiceConnectorItems": @[ @{ @"VoiceConnectorId": @"", @"Priority": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/voice-connector-groups"]
                                                       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}}/voice-connector-groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/voice-connector-groups",
  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' => '',
    'VoiceConnectorItems' => [
        [
                'VoiceConnectorId' => '',
                'Priority' => ''
        ]
    ]
  ]),
  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}}/voice-connector-groups', [
  'body' => '{
  "Name": "",
  "VoiceConnectorItems": [
    {
      "VoiceConnectorId": "",
      "Priority": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/voice-connector-groups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'VoiceConnectorItems' => [
    [
        'VoiceConnectorId' => '',
        'Priority' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'VoiceConnectorItems' => [
    [
        'VoiceConnectorId' => '',
        'Priority' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/voice-connector-groups');
$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}}/voice-connector-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "VoiceConnectorItems": [
    {
      "VoiceConnectorId": "",
      "Priority": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/voice-connector-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "VoiceConnectorItems": [
    {
      "VoiceConnectorId": "",
      "Priority": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/voice-connector-groups", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/voice-connector-groups"

payload = {
    "Name": "",
    "VoiceConnectorItems": [
        {
            "VoiceConnectorId": "",
            "Priority": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/voice-connector-groups"

payload <- "{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\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}}/voice-connector-groups")

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  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\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/voice-connector-groups') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"VoiceConnectorItems\": [\n    {\n      \"VoiceConnectorId\": \"\",\n      \"Priority\": \"\"\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}}/voice-connector-groups";

    let payload = json!({
        "Name": "",
        "VoiceConnectorItems": (
            json!({
                "VoiceConnectorId": "",
                "Priority": ""
            })
        )
    });

    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": "",
  "VoiceConnectorItems": [
    {
      "VoiceConnectorId": "",
      "Priority": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/voice-connector-groups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "VoiceConnectorItems": [\n    {\n      "VoiceConnectorId": "",\n      "Priority": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/voice-connector-groups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "VoiceConnectorItems": [
    [
      "VoiceConnectorId": "",
      "Priority": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/voice-connector-groups")! 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}}/accounts/:accountId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:accountId")

require "http/client"

url = "{{baseUrl}}/accounts/:accountId"

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}}/accounts/:accountId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:accountId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:accountId"

	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/accounts/:accountId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:accountId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId"))
    .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}}/accounts/:accountId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:accountId")
  .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}}/accounts/:accountId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/accounts/:accountId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:accountId';
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}}/accounts/:accountId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId',
  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}}/accounts/:accountId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:accountId');

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}}/accounts/:accountId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:accountId';
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}}/accounts/:accountId"]
                                                       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}}/accounts/:accountId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId",
  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}}/accounts/:accountId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:accountId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:accountId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId")

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/accounts/:accountId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId";

    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}}/accounts/:accountId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:accountId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId")! 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}}/app-instances/:appInstanceArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/app-instances/:appInstanceArn")

require "http/client"

url = "{{baseUrl}}/app-instances/:appInstanceArn"

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}}/app-instances/:appInstanceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/app-instances/:appInstanceArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/app-instances/:appInstanceArn"

	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/app-instances/:appInstanceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/app-instances/:appInstanceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/app-instances/:appInstanceArn"))
    .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}}/app-instances/:appInstanceArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/app-instances/:appInstanceArn")
  .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}}/app-instances/:appInstanceArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/app-instances/:appInstanceArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/app-instances/:appInstanceArn';
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}}/app-instances/:appInstanceArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/app-instances/:appInstanceArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/app-instances/:appInstanceArn',
  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}}/app-instances/:appInstanceArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/app-instances/:appInstanceArn');

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}}/app-instances/:appInstanceArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/app-instances/:appInstanceArn';
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}}/app-instances/:appInstanceArn"]
                                                       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}}/app-instances/:appInstanceArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/app-instances/:appInstanceArn",
  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}}/app-instances/:appInstanceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/app-instances/:appInstanceArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/app-instances/:appInstanceArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/app-instances/:appInstanceArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/app-instances/:appInstanceArn' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/app-instances/:appInstanceArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/app-instances/:appInstanceArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/app-instances/:appInstanceArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/app-instances/:appInstanceArn")

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/app-instances/:appInstanceArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/app-instances/:appInstanceArn";

    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}}/app-instances/:appInstanceArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/app-instances/:appInstanceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/app-instances/:appInstanceArn")! 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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn")

require "http/client"

url = "{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn"

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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn"

	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/app-instances/:appInstanceArn/admins/:appInstanceAdminArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn"))
    .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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn")
  .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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn';
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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/app-instances/:appInstanceArn/admins/:appInstanceAdminArn',
  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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn');

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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn';
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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn"]
                                                       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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn",
  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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn');

echo $response->getBody();

setUrl('{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/app-instances/:appInstanceArn/admins/:appInstanceAdminArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn")

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/app-instances/:appInstanceArn/admins/:appInstanceAdminArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn";

    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}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/app-instances/:appInstanceArn/admins/:appInstanceAdminArn")! 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}}/app-instances/:appInstanceArn/streaming-configurations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations")

require "http/client"

url = "{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations"

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}}/app-instances/:appInstanceArn/streaming-configurations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations"

	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/app-instances/:appInstanceArn/streaming-configurations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations"))
    .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}}/app-instances/:appInstanceArn/streaming-configurations")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations")
  .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}}/app-instances/:appInstanceArn/streaming-configurations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations';
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}}/app-instances/:appInstanceArn/streaming-configurations',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/app-instances/:appInstanceArn/streaming-configurations',
  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}}/app-instances/:appInstanceArn/streaming-configurations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations');

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}}/app-instances/:appInstanceArn/streaming-configurations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations';
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}}/app-instances/:appInstanceArn/streaming-configurations"]
                                                       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}}/app-instances/:appInstanceArn/streaming-configurations" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations",
  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}}/app-instances/:appInstanceArn/streaming-configurations');

echo $response->getBody();

setUrl('{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/app-instances/:appInstanceArn/streaming-configurations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations")

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/app-instances/:appInstanceArn/streaming-configurations') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations";

    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}}/app-instances/:appInstanceArn/streaming-configurations

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/app-instances/:appInstanceArn/streaming-configurations")! 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}}/app-instance-users/:appInstanceUserArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/app-instance-users/:appInstanceUserArn")

require "http/client"

url = "{{baseUrl}}/app-instance-users/:appInstanceUserArn"

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}}/app-instance-users/:appInstanceUserArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/app-instance-users/:appInstanceUserArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/app-instance-users/:appInstanceUserArn"

	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/app-instance-users/:appInstanceUserArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/app-instance-users/:appInstanceUserArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/app-instance-users/:appInstanceUserArn"))
    .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}}/app-instance-users/:appInstanceUserArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/app-instance-users/:appInstanceUserArn")
  .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}}/app-instance-users/:appInstanceUserArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/app-instance-users/:appInstanceUserArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/app-instance-users/:appInstanceUserArn';
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}}/app-instance-users/:appInstanceUserArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/app-instance-users/:appInstanceUserArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/app-instance-users/:appInstanceUserArn',
  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}}/app-instance-users/:appInstanceUserArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/app-instance-users/:appInstanceUserArn');

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}}/app-instance-users/:appInstanceUserArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/app-instance-users/:appInstanceUserArn';
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}}/app-instance-users/:appInstanceUserArn"]
                                                       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}}/app-instance-users/:appInstanceUserArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/app-instance-users/:appInstanceUserArn",
  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}}/app-instance-users/:appInstanceUserArn');

echo $response->getBody();

setUrl('{{baseUrl}}/app-instance-users/:appInstanceUserArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/app-instance-users/:appInstanceUserArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/app-instance-users/:appInstanceUserArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/app-instance-users/:appInstanceUserArn' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/app-instance-users/:appInstanceUserArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/app-instance-users/:appInstanceUserArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/app-instance-users/:appInstanceUserArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/app-instance-users/:appInstanceUserArn")

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/app-instance-users/:appInstanceUserArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/app-instance-users/:appInstanceUserArn";

    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}}/app-instance-users/:appInstanceUserArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/app-instance-users/:appInstanceUserArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/app-instance-users/:appInstanceUserArn")! 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}}/meetings/:meetingId/attendees/:attendeeId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId")

require "http/client"

url = "{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId"

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}}/meetings/:meetingId/attendees/:attendeeId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId"

	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/meetings/:meetingId/attendees/:attendeeId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId"))
    .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}}/meetings/:meetingId/attendees/:attendeeId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId")
  .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}}/meetings/:meetingId/attendees/:attendeeId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId';
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}}/meetings/:meetingId/attendees/:attendeeId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/meetings/:meetingId/attendees/:attendeeId',
  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}}/meetings/:meetingId/attendees/:attendeeId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId');

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}}/meetings/:meetingId/attendees/:attendeeId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId';
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}}/meetings/:meetingId/attendees/:attendeeId"]
                                                       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}}/meetings/:meetingId/attendees/:attendeeId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId",
  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}}/meetings/:meetingId/attendees/:attendeeId');

echo $response->getBody();

setUrl('{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/meetings/:meetingId/attendees/:attendeeId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId")

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/meetings/:meetingId/attendees/:attendeeId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId";

    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}}/meetings/:meetingId/attendees/:attendeeId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/meetings/:meetingId/attendees/:attendeeId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/meetings/:meetingId/attendees/:attendeeId")! 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}}/channels/:channelArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/channels/:channelArn")

require "http/client"

url = "{{baseUrl}}/channels/:channelArn"

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}}/channels/:channelArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:channelArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels/:channelArn"

	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/channels/:channelArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/channels/:channelArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channelArn"))
    .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}}/channels/:channelArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/channels/:channelArn")
  .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}}/channels/:channelArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/channels/:channelArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels/:channelArn';
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}}/channels/:channelArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channelArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:channelArn',
  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}}/channels/:channelArn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/channels/:channelArn');

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}}/channels/:channelArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels/:channelArn';
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}}/channels/:channelArn"]
                                                       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}}/channels/:channelArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels/:channelArn",
  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}}/channels/:channelArn');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channelArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels/:channelArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:channelArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channelArn' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/channels/:channelArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels/:channelArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channelArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channelArn")

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/channels/:channelArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channelArn";

    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}}/channels/:channelArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/channels/:channelArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channelArn")! 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}}/channels/:channelArn/bans/:memberArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/channels/:channelArn/bans/:memberArn")

require "http/client"

url = "{{baseUrl}}/channels/:channelArn/bans/:memberArn"

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}}/channels/:channelArn/bans/:memberArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:channelArn/bans/:memberArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels/:channelArn/bans/:memberArn"

	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/channels/:channelArn/bans/:memberArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/channels/:channelArn/bans/:memberArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channelArn/bans/:memberArn"))
    .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}}/channels/:channelArn/bans/:memberArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/channels/:channelArn/bans/:memberArn")
  .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}}/channels/:channelArn/bans/:memberArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/channels/:channelArn/bans/:memberArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels/:channelArn/bans/:memberArn';
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}}/channels/:channelArn/bans/:memberArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channelArn/bans/:memberArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:channelArn/bans/:memberArn',
  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}}/channels/:channelArn/bans/:memberArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/channels/:channelArn/bans/:memberArn');

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}}/channels/:channelArn/bans/:memberArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels/:channelArn/bans/:memberArn';
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}}/channels/:channelArn/bans/:memberArn"]
                                                       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}}/channels/:channelArn/bans/:memberArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels/:channelArn/bans/:memberArn",
  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}}/channels/:channelArn/bans/:memberArn');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channelArn/bans/:memberArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels/:channelArn/bans/:memberArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:channelArn/bans/:memberArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channelArn/bans/:memberArn' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/channels/:channelArn/bans/:memberArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels/:channelArn/bans/:memberArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channelArn/bans/:memberArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channelArn/bans/:memberArn")

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/channels/:channelArn/bans/:memberArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channelArn/bans/:memberArn";

    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}}/channels/:channelArn/bans/:memberArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/channels/:channelArn/bans/:memberArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channelArn/bans/:memberArn")! 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}}/channels/:channelArn/memberships/:memberArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/channels/:channelArn/memberships/:memberArn")

require "http/client"

url = "{{baseUrl}}/channels/:channelArn/memberships/:memberArn"

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}}/channels/:channelArn/memberships/:memberArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:channelArn/memberships/:memberArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels/:channelArn/memberships/:memberArn"

	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/channels/:channelArn/memberships/:memberArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/channels/:channelArn/memberships/:memberArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channelArn/memberships/:memberArn"))
    .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}}/channels/:channelArn/memberships/:memberArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/channels/:channelArn/memberships/:memberArn")
  .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}}/channels/:channelArn/memberships/:memberArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/channels/:channelArn/memberships/:memberArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels/:channelArn/memberships/:memberArn';
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}}/channels/:channelArn/memberships/:memberArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channelArn/memberships/:memberArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:channelArn/memberships/:memberArn',
  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}}/channels/:channelArn/memberships/:memberArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/channels/:channelArn/memberships/:memberArn');

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}}/channels/:channelArn/memberships/:memberArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels/:channelArn/memberships/:memberArn';
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}}/channels/:channelArn/memberships/:memberArn"]
                                                       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}}/channels/:channelArn/memberships/:memberArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels/:channelArn/memberships/:memberArn",
  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}}/channels/:channelArn/memberships/:memberArn');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channelArn/memberships/:memberArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels/:channelArn/memberships/:memberArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:channelArn/memberships/:memberArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channelArn/memberships/:memberArn' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/channels/:channelArn/memberships/:memberArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels/:channelArn/memberships/:memberArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channelArn/memberships/:memberArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channelArn/memberships/:memberArn")

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/channels/:channelArn/memberships/:memberArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channelArn/memberships/:memberArn";

    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}}/channels/:channelArn/memberships/:memberArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/channels/:channelArn/memberships/:memberArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channelArn/memberships/:memberArn")! 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}}/channels/:channelArn/messages/:messageId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/channels/:channelArn/messages/:messageId")

require "http/client"

url = "{{baseUrl}}/channels/:channelArn/messages/:messageId"

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}}/channels/:channelArn/messages/:messageId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:channelArn/messages/:messageId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels/:channelArn/messages/:messageId"

	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/channels/:channelArn/messages/:messageId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/channels/:channelArn/messages/:messageId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channelArn/messages/:messageId"))
    .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}}/channels/:channelArn/messages/:messageId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/channels/:channelArn/messages/:messageId")
  .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}}/channels/:channelArn/messages/:messageId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/channels/:channelArn/messages/:messageId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels/:channelArn/messages/:messageId';
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}}/channels/:channelArn/messages/:messageId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channelArn/messages/:messageId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:channelArn/messages/:messageId',
  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}}/channels/:channelArn/messages/:messageId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/channels/:channelArn/messages/:messageId');

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}}/channels/:channelArn/messages/:messageId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels/:channelArn/messages/:messageId';
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}}/channels/:channelArn/messages/:messageId"]
                                                       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}}/channels/:channelArn/messages/:messageId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels/:channelArn/messages/:messageId",
  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}}/channels/:channelArn/messages/:messageId');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channelArn/messages/:messageId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels/:channelArn/messages/:messageId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:channelArn/messages/:messageId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channelArn/messages/:messageId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/channels/:channelArn/messages/:messageId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels/:channelArn/messages/:messageId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channelArn/messages/:messageId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channelArn/messages/:messageId")

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/channels/:channelArn/messages/:messageId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channelArn/messages/:messageId";

    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}}/channels/:channelArn/messages/:messageId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/channels/:channelArn/messages/:messageId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channelArn/messages/:messageId")! 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}}/channels/:channelArn/moderators/:channelModeratorArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn")

require "http/client"

url = "{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn"

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}}/channels/:channelArn/moderators/:channelModeratorArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn"

	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/channels/:channelArn/moderators/:channelModeratorArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn"))
    .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}}/channels/:channelArn/moderators/:channelModeratorArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn")
  .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}}/channels/:channelArn/moderators/:channelModeratorArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn';
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}}/channels/:channelArn/moderators/:channelModeratorArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:channelArn/moderators/:channelModeratorArn',
  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}}/channels/:channelArn/moderators/:channelModeratorArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn');

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}}/channels/:channelArn/moderators/:channelModeratorArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn';
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}}/channels/:channelArn/moderators/:channelModeratorArn"]
                                                       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}}/channels/:channelArn/moderators/:channelModeratorArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn",
  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}}/channels/:channelArn/moderators/:channelModeratorArn');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/channels/:channelArn/moderators/:channelModeratorArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn")

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/channels/:channelArn/moderators/:channelModeratorArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn";

    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}}/channels/:channelArn/moderators/:channelModeratorArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channelArn/moderators/:channelModeratorArn")! 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}}/accounts/:accountId/bots/:botId/events-configuration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration")

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration"

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}}/accounts/:accountId/bots/:botId/events-configuration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration"

	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/accounts/:accountId/bots/:botId/events-configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration"))
    .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}}/accounts/:accountId/bots/:botId/events-configuration")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration")
  .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}}/accounts/:accountId/bots/:botId/events-configuration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration';
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}}/accounts/:accountId/bots/:botId/events-configuration',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/bots/:botId/events-configuration',
  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}}/accounts/:accountId/bots/:botId/events-configuration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration');

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}}/accounts/:accountId/bots/:botId/events-configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration';
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}}/accounts/:accountId/bots/:botId/events-configuration"]
                                                       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}}/accounts/:accountId/bots/:botId/events-configuration" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration",
  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}}/accounts/:accountId/bots/:botId/events-configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:accountId/bots/:botId/events-configuration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration")

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/accounts/:accountId/bots/:botId/events-configuration') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration";

    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}}/accounts/:accountId/bots/:botId/events-configuration

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/bots/:botId/events-configuration")! 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}}/media-capture-pipelines/:mediaPipelineId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/media-capture-pipelines/:mediaPipelineId")

require "http/client"

url = "{{baseUrl}}/media-capture-pipelines/:mediaPipelineId"

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}}/media-capture-pipelines/:mediaPipelineId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/media-capture-pipelines/:mediaPipelineId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/media-capture-pipelines/:mediaPipelineId"

	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/media-capture-pipelines/:mediaPipelineId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/media-capture-pipelines/:mediaPipelineId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/media-capture-pipelines/:mediaPipelineId"))
    .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}}/media-capture-pipelines/:mediaPipelineId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/media-capture-pipelines/:mediaPipelineId")
  .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}}/media-capture-pipelines/:mediaPipelineId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/media-capture-pipelines/:mediaPipelineId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/media-capture-pipelines/:mediaPipelineId';
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}}/media-capture-pipelines/:mediaPipelineId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/media-capture-pipelines/:mediaPipelineId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/media-capture-pipelines/:mediaPipelineId',
  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}}/media-capture-pipelines/:mediaPipelineId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/media-capture-pipelines/:mediaPipelineId');

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}}/media-capture-pipelines/:mediaPipelineId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/media-capture-pipelines/:mediaPipelineId';
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}}/media-capture-pipelines/:mediaPipelineId"]
                                                       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}}/media-capture-pipelines/:mediaPipelineId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/media-capture-pipelines/:mediaPipelineId",
  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}}/media-capture-pipelines/:mediaPipelineId');

echo $response->getBody();

setUrl('{{baseUrl}}/media-capture-pipelines/:mediaPipelineId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/media-capture-pipelines/:mediaPipelineId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/media-capture-pipelines/:mediaPipelineId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/media-capture-pipelines/:mediaPipelineId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/media-capture-pipelines/:mediaPipelineId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/media-capture-pipelines/:mediaPipelineId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/media-capture-pipelines/:mediaPipelineId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/media-capture-pipelines/:mediaPipelineId")

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/media-capture-pipelines/:mediaPipelineId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/media-capture-pipelines/:mediaPipelineId";

    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}}/media-capture-pipelines/:mediaPipelineId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/media-capture-pipelines/:mediaPipelineId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/media-capture-pipelines/:mediaPipelineId")! 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}}/meetings/:meetingId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/meetings/:meetingId")

require "http/client"

url = "{{baseUrl}}/meetings/:meetingId"

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}}/meetings/:meetingId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/meetings/:meetingId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/meetings/:meetingId"

	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/meetings/:meetingId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/meetings/:meetingId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/meetings/:meetingId"))
    .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}}/meetings/:meetingId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/meetings/:meetingId")
  .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}}/meetings/:meetingId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/meetings/:meetingId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/meetings/:meetingId';
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}}/meetings/:meetingId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/meetings/:meetingId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/meetings/:meetingId',
  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}}/meetings/:meetingId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/meetings/:meetingId');

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}}/meetings/:meetingId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/meetings/:meetingId';
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}}/meetings/:meetingId"]
                                                       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}}/meetings/:meetingId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/meetings/:meetingId",
  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}}/meetings/:meetingId');

echo $response->getBody();

setUrl('{{baseUrl}}/meetings/:meetingId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/meetings/:meetingId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/meetings/:meetingId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/meetings/:meetingId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/meetings/:meetingId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/meetings/:meetingId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/meetings/:meetingId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/meetings/:meetingId")

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/meetings/:meetingId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/meetings/:meetingId";

    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}}/meetings/:meetingId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/meetings/:meetingId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/meetings/:meetingId")! 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}}/phone-numbers/:phoneNumberId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/phone-numbers/:phoneNumberId")

require "http/client"

url = "{{baseUrl}}/phone-numbers/:phoneNumberId"

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}}/phone-numbers/: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-numbers/:phoneNumberId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/phone-numbers/:phoneNumberId"

	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/phone-numbers/:phoneNumberId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/phone-numbers/:phoneNumberId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/phone-numbers/:phoneNumberId"))
    .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}}/phone-numbers/:phoneNumberId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/phone-numbers/: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('DELETE', '{{baseUrl}}/phone-numbers/:phoneNumberId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/phone-numbers/:phoneNumberId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/phone-numbers/:phoneNumberId';
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}}/phone-numbers/:phoneNumberId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/phone-numbers/:phoneNumberId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/phone-numbers/: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: 'DELETE',
  url: '{{baseUrl}}/phone-numbers/:phoneNumberId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/phone-numbers/: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: 'DELETE',
  url: '{{baseUrl}}/phone-numbers/: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-numbers/:phoneNumberId';
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}}/phone-numbers/:phoneNumberId"]
                                                       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}}/phone-numbers/:phoneNumberId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/phone-numbers/:phoneNumberId",
  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}}/phone-numbers/:phoneNumberId');

echo $response->getBody();

setUrl('{{baseUrl}}/phone-numbers/:phoneNumberId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/phone-numbers/:phoneNumberId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/phone-numbers/:phoneNumberId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/phone-numbers/:phoneNumberId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/phone-numbers/:phoneNumberId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/phone-numbers/:phoneNumberId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/phone-numbers/:phoneNumberId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/phone-numbers/:phoneNumberId")

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/phone-numbers/:phoneNumberId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/phone-numbers/:phoneNumberId";

    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}}/phone-numbers/:phoneNumberId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/phone-numbers/:phoneNumberId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/phone-numbers/:phoneNumberId")! 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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId")

require "http/client"

url = "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId"

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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId"

	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/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId"))
    .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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId")
  .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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId';
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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId',
  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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId');

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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId';
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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId"]
                                                       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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId",
  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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId');

echo $response->getBody();

setUrl('{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId")

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/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId";

    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}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/voice-connectors/:voiceConnectorId/proxy-sessions/:proxySessionId")! 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}}/accounts/:accountId/rooms/:roomId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:accountId/rooms/:roomId")

require "http/client"

url = "{{baseUrl}}/accounts/:accountId/rooms/:roomId"

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}}/accounts/:accountId/rooms/:roomId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:accountId/rooms/:roomId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:accountId/rooms/:roomId"

	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/accounts/:accountId/rooms/:roomId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:accountId/rooms/:roomId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:accountId/rooms/:roomId"))
    .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}}/accounts/:accountId/rooms/:roomId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:accountId/rooms/:roomId")
  .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}}/accounts/:accountId/rooms/:roomId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:accountId/rooms/:roomId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:accountId/rooms/:roomId';
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}}/accounts/:accountId/rooms/:roomId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:accountId/rooms/:roomId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:accountId/rooms/:roomId',
  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}}/accounts/:accountId/rooms/:roomId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:accountId/rooms/:roomId');

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}}/accounts/:accountId/rooms/:roomId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:accountId/rooms/:roomId';
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}}/accounts/:accountId/rooms/:roomId"]
                                                       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}}/accounts/:accountId/rooms/:roomId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:accountId/rooms/:roomId",
  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}}/accounts/:accountId/rooms/:roomId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:accountId/rooms/:roomId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:accountId/rooms/:roomId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:accountId/rooms/:roomId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:accountId/rooms/:roomId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:accountId/rooms/:roomId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:accountId/rooms/:roomId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:accountId/rooms/:roomId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:accountId/rooms/:roomId")

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/accounts/:accountId/rooms/:roomId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:accountId/rooms/:roomId";

    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}}/accounts/:accountId/rooms/:roomId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:accountId/rooms/:roomId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:accountId/rooms/:roomId")! 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()