CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/telephony_credentials/:id/token");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/telephony_credentials/:id/token")

require "http/client"

url = "{{baseUrl}}/telephony_credentials/:id/token"

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

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

var client = new RestClient("{{baseUrl}}/telephony_credentials/:id/token");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/telephony_credentials/:id/token"

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

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

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

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

}

POST /baseUrl/telephony_credentials/:id/token HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/telephony_credentials/:id/token")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/telephony_credentials/:id/token")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/telephony_credentials/:id/token")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/telephony_credentials/:id/token');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/telephony_credentials/:id/token'
};

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

const url = '{{baseUrl}}/telephony_credentials/:id/token';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/telephony_credentials/:id/token',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/telephony_credentials/:id/token")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/telephony_credentials/:id/token',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/telephony_credentials/:id/token'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/telephony_credentials/:id/token');

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}}/telephony_credentials/:id/token'
};

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

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

const url = '{{baseUrl}}/telephony_credentials/:id/token';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/telephony_credentials/:id/token"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/telephony_credentials/:id/token" in

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

 "{{baseUrl}}/telephony_credentials/:id/token",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/telephony_credentials/:id/token');

echo $response->getBody();

setUrl('{{baseUrl}}/telephony_credentials/:id/token');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/telephony_credentials/:id/token');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/telephony_credentials/:id/token' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/telephony_credentials/:id/token' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/telephony_credentials/:id/token")

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

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

import requests

url = "{{baseUrl}}/telephony_credentials/:id/token"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/telephony_credentials/:id/token"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/telephony_credentials/:id/token")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/telephony_credentials/:id/token') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/telephony_credentials/:id/token

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/telephony_credentials/:id/token

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/telephony_credentials/:id/token")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/addresses" {:content-type :json
                                                      :form-params {:address_book false
                                                                    :administrative_area ""
                                                                    :borough ""
                                                                    :business_name ""
                                                                    :country_code ""
                                                                    :customer_reference ""
                                                                    :extended_address ""
                                                                    :first_name ""
                                                                    :last_name ""
                                                                    :locality ""
                                                                    :neighborhood ""
                                                                    :phone_number ""
                                                                    :postal_code ""
                                                                    :street_address ""
                                                                    :validate_address false}})

require "http/client"

url = "{{baseUrl}}/addresses"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": 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}}/addresses"),
    Content = new StringContent("{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": 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}}/addresses");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": 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/addresses HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 347

{
  "address_book": false,
  "administrative_area": "",
  "borough": "",
  "business_name": "",
  "country_code": "",
  "customer_reference": "",
  "extended_address": "",
  "first_name": "",
  "last_name": "",
  "locality": "",
  "neighborhood": "",
  "phone_number": "",
  "postal_code": "",
  "street_address": "",
  "validate_address": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/addresses")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/addresses"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": 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  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/addresses")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/addresses")
  .header("content-type", "application/json")
  .body("{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": false\n}")
  .asString();

const data = JSON.stringify({
  address_book: false,
  administrative_area: '',
  borough: '',
  business_name: '',
  country_code: '',
  customer_reference: '',
  extended_address: '',
  first_name: '',
  last_name: '',
  locality: '',
  neighborhood: '',
  phone_number: '',
  postal_code: '',
  street_address: '',
  validate_address: 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}}/addresses');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/addresses',
  headers: {'content-type': 'application/json'},
  data: {
    address_book: false,
    administrative_area: '',
    borough: '',
    business_name: '',
    country_code: '',
    customer_reference: '',
    extended_address: '',
    first_name: '',
    last_name: '',
    locality: '',
    neighborhood: '',
    phone_number: '',
    postal_code: '',
    street_address: '',
    validate_address: false
  }
};

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

const url = '{{baseUrl}}/addresses';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address_book":false,"administrative_area":"","borough":"","business_name":"","country_code":"","customer_reference":"","extended_address":"","first_name":"","last_name":"","locality":"","neighborhood":"","phone_number":"","postal_code":"","street_address":"","validate_address":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}}/addresses',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address_book": false,\n  "administrative_area": "",\n  "borough": "",\n  "business_name": "",\n  "country_code": "",\n  "customer_reference": "",\n  "extended_address": "",\n  "first_name": "",\n  "last_name": "",\n  "locality": "",\n  "neighborhood": "",\n  "phone_number": "",\n  "postal_code": "",\n  "street_address": "",\n  "validate_address": 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  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/addresses")
  .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/addresses',
  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({
  address_book: false,
  administrative_area: '',
  borough: '',
  business_name: '',
  country_code: '',
  customer_reference: '',
  extended_address: '',
  first_name: '',
  last_name: '',
  locality: '',
  neighborhood: '',
  phone_number: '',
  postal_code: '',
  street_address: '',
  validate_address: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/addresses',
  headers: {'content-type': 'application/json'},
  body: {
    address_book: false,
    administrative_area: '',
    borough: '',
    business_name: '',
    country_code: '',
    customer_reference: '',
    extended_address: '',
    first_name: '',
    last_name: '',
    locality: '',
    neighborhood: '',
    phone_number: '',
    postal_code: '',
    street_address: '',
    validate_address: 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}}/addresses');

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

req.type('json');
req.send({
  address_book: false,
  administrative_area: '',
  borough: '',
  business_name: '',
  country_code: '',
  customer_reference: '',
  extended_address: '',
  first_name: '',
  last_name: '',
  locality: '',
  neighborhood: '',
  phone_number: '',
  postal_code: '',
  street_address: '',
  validate_address: 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}}/addresses',
  headers: {'content-type': 'application/json'},
  data: {
    address_book: false,
    administrative_area: '',
    borough: '',
    business_name: '',
    country_code: '',
    customer_reference: '',
    extended_address: '',
    first_name: '',
    last_name: '',
    locality: '',
    neighborhood: '',
    phone_number: '',
    postal_code: '',
    street_address: '',
    validate_address: false
  }
};

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

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

const url = '{{baseUrl}}/addresses';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address_book":false,"administrative_area":"","borough":"","business_name":"","country_code":"","customer_reference":"","extended_address":"","first_name":"","last_name":"","locality":"","neighborhood":"","phone_number":"","postal_code":"","street_address":"","validate_address":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 = @{ @"address_book": @NO,
                              @"administrative_area": @"",
                              @"borough": @"",
                              @"business_name": @"",
                              @"country_code": @"",
                              @"customer_reference": @"",
                              @"extended_address": @"",
                              @"first_name": @"",
                              @"last_name": @"",
                              @"locality": @"",
                              @"neighborhood": @"",
                              @"phone_number": @"",
                              @"postal_code": @"",
                              @"street_address": @"",
                              @"validate_address": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/addresses"]
                                                       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}}/addresses" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": false\n}" in

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

 "{{baseUrl}}/addresses",
  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([
    'address_book' => null,
    'administrative_area' => '',
    'borough' => '',
    'business_name' => '',
    'country_code' => '',
    'customer_reference' => '',
    'extended_address' => '',
    'first_name' => '',
    'last_name' => '',
    'locality' => '',
    'neighborhood' => '',
    'phone_number' => '',
    'postal_code' => '',
    'street_address' => '',
    'validate_address' => 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}}/addresses', [
  'body' => '{
  "address_book": false,
  "administrative_area": "",
  "borough": "",
  "business_name": "",
  "country_code": "",
  "customer_reference": "",
  "extended_address": "",
  "first_name": "",
  "last_name": "",
  "locality": "",
  "neighborhood": "",
  "phone_number": "",
  "postal_code": "",
  "street_address": "",
  "validate_address": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/addresses');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address_book' => null,
  'administrative_area' => '',
  'borough' => '',
  'business_name' => '',
  'country_code' => '',
  'customer_reference' => '',
  'extended_address' => '',
  'first_name' => '',
  'last_name' => '',
  'locality' => '',
  'neighborhood' => '',
  'phone_number' => '',
  'postal_code' => '',
  'street_address' => '',
  'validate_address' => null
]));

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

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

append(json_encode([
  'address_book' => null,
  'administrative_area' => '',
  'borough' => '',
  'business_name' => '',
  'country_code' => '',
  'customer_reference' => '',
  'extended_address' => '',
  'first_name' => '',
  'last_name' => '',
  'locality' => '',
  'neighborhood' => '',
  'phone_number' => '',
  'postal_code' => '',
  'street_address' => '',
  'validate_address' => null
]));
$request->setRequestUrl('{{baseUrl}}/addresses');
$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}}/addresses' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address_book": false,
  "administrative_area": "",
  "borough": "",
  "business_name": "",
  "country_code": "",
  "customer_reference": "",
  "extended_address": "",
  "first_name": "",
  "last_name": "",
  "locality": "",
  "neighborhood": "",
  "phone_number": "",
  "postal_code": "",
  "street_address": "",
  "validate_address": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/addresses' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address_book": false,
  "administrative_area": "",
  "borough": "",
  "business_name": "",
  "country_code": "",
  "customer_reference": "",
  "extended_address": "",
  "first_name": "",
  "last_name": "",
  "locality": "",
  "neighborhood": "",
  "phone_number": "",
  "postal_code": "",
  "street_address": "",
  "validate_address": false
}'

import http.client

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

payload = "{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": false\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/addresses"

payload = {
    "address_book": False,
    "administrative_area": "",
    "borough": "",
    "business_name": "",
    "country_code": "",
    "customer_reference": "",
    "extended_address": "",
    "first_name": "",
    "last_name": "",
    "locality": "",
    "neighborhood": "",
    "phone_number": "",
    "postal_code": "",
    "street_address": "",
    "validate_address": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": 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}}/addresses")

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  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": 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/addresses') do |req|
  req.body = "{\n  \"address_book\": false,\n  \"administrative_area\": \"\",\n  \"borough\": \"\",\n  \"business_name\": \"\",\n  \"country_code\": \"\",\n  \"customer_reference\": \"\",\n  \"extended_address\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"locality\": \"\",\n  \"neighborhood\": \"\",\n  \"phone_number\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\",\n  \"validate_address\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "address_book": false,
        "administrative_area": "",
        "borough": "",
        "business_name": "",
        "country_code": "",
        "customer_reference": "",
        "extended_address": "",
        "first_name": "",
        "last_name": "",
        "locality": "",
        "neighborhood": "",
        "phone_number": "",
        "postal_code": "",
        "street_address": "",
        "validate_address": 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 '{
  "address_book": false,
  "administrative_area": "",
  "borough": "",
  "business_name": "",
  "country_code": "",
  "customer_reference": "",
  "extended_address": "",
  "first_name": "",
  "last_name": "",
  "locality": "",
  "neighborhood": "",
  "phone_number": "",
  "postal_code": "",
  "street_address": "",
  "validate_address": false
}' |  \
  http POST {{baseUrl}}/addresses \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "address_book": false,\n  "administrative_area": "",\n  "borough": "",\n  "business_name": "",\n  "country_code": "",\n  "customer_reference": "",\n  "extended_address": "",\n  "first_name": "",\n  "last_name": "",\n  "locality": "",\n  "neighborhood": "",\n  "phone_number": "",\n  "postal_code": "",\n  "street_address": "",\n  "validate_address": false\n}' \
  --output-document \
  - {{baseUrl}}/addresses

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address_book": false,
  "administrative_area": "",
  "borough": "",
  "business_name": "",
  "country_code": "",
  "customer_reference": "",
  "extended_address": "",
  "first_name": "",
  "last_name": "",
  "locality": "",
  "neighborhood": "",
  "phone_number": "",
  "postal_code": "",
  "street_address": "",
  "validate_address": false
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/addresses/:id")

require "http/client"

url = "{{baseUrl}}/addresses/:id"

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}}/addresses/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/addresses/:id"

	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/addresses/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/addresses/:id"))
    .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}}/addresses/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/addresses/:id")
  .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}}/addresses/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/addresses/:id'};

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

const url = '{{baseUrl}}/addresses/:id';
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}}/addresses/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/addresses/:id',
  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}}/addresses/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/addresses/:id');

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}}/addresses/:id'};

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

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

const url = '{{baseUrl}}/addresses/:id';
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}}/addresses/:id"]
                                                       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}}/addresses/:id" in

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

 "{{baseUrl}}/addresses/:id",
  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}}/addresses/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/addresses/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/addresses/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/addresses/:id")

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

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

import requests

url = "{{baseUrl}}/addresses/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/addresses/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/addresses/:id")

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/addresses/:id') do |req|
end

puts response.status
puts response.body

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

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

    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}}/addresses/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/addresses/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/addresses/:id")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/addresses");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/addresses")

require "http/client"

url = "{{baseUrl}}/addresses"

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

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

var client = new RestClient("{{baseUrl}}/addresses");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/addresses HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/addresses")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/addresses")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/addresses');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/addresses'};

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

const url = '{{baseUrl}}/addresses';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/addresses',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/addresses")
  .get()
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/addresses'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/addresses');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/addresses'};

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

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

const url = '{{baseUrl}}/addresses';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/addresses" in

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

 "{{baseUrl}}/addresses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/addresses');

echo $response->getBody();

setUrl('{{baseUrl}}/addresses');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/addresses');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/addresses' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/addresses' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/addresses")

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

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

import requests

url = "{{baseUrl}}/addresses"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/addresses') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/addresses

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/addresses

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/addresses/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/addresses/:id")

require "http/client"

url = "{{baseUrl}}/addresses/:id"

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

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

var client = new RestClient("{{baseUrl}}/addresses/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/addresses/:id"

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

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

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

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

}

GET /baseUrl/addresses/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/addresses/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/addresses/:id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/addresses/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/addresses/:id'};

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

const url = '{{baseUrl}}/addresses/:id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/addresses/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/addresses/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/addresses/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/addresses/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/addresses/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/addresses/:id'};

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

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

const url = '{{baseUrl}}/addresses/:id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/addresses/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/addresses/:id" in

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

 "{{baseUrl}}/addresses/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/addresses/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/addresses/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/addresses/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/addresses/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/addresses/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/addresses/:id")

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

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

import requests

url = "{{baseUrl}}/addresses/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/addresses/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/addresses/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/addresses/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/addresses/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/addresses/:id

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/addresses/actions/validate");

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  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/addresses/actions/validate" {:content-type :json
                                                                       :form-params {:administrative_area ""
                                                                                     :country_code ""
                                                                                     :extended_address ""
                                                                                     :locality ""
                                                                                     :postal_code ""
                                                                                     :street_address ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/addresses/actions/validate"

	payload := strings.NewReader("{\n  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\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/addresses/actions/validate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 142

{
  "administrative_area": "",
  "country_code": "",
  "extended_address": "",
  "locality": "",
  "postal_code": "",
  "street_address": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/addresses/actions/validate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/addresses/actions/validate")
  .header("content-type", "application/json")
  .body("{\n  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  administrative_area: '',
  country_code: '',
  extended_address: '',
  locality: '',
  postal_code: '',
  street_address: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/addresses/actions/validate',
  headers: {'content-type': 'application/json'},
  data: {
    administrative_area: '',
    country_code: '',
    extended_address: '',
    locality: '',
    postal_code: '',
    street_address: ''
  }
};

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

const url = '{{baseUrl}}/addresses/actions/validate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"administrative_area":"","country_code":"","extended_address":"","locality":"","postal_code":"","street_address":""}'
};

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}}/addresses/actions/validate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "administrative_area": "",\n  "country_code": "",\n  "extended_address": "",\n  "locality": "",\n  "postal_code": "",\n  "street_address": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/addresses/actions/validate")
  .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/addresses/actions/validate',
  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({
  administrative_area: '',
  country_code: '',
  extended_address: '',
  locality: '',
  postal_code: '',
  street_address: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/addresses/actions/validate',
  headers: {'content-type': 'application/json'},
  body: {
    administrative_area: '',
    country_code: '',
    extended_address: '',
    locality: '',
    postal_code: '',
    street_address: ''
  },
  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}}/addresses/actions/validate');

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

req.type('json');
req.send({
  administrative_area: '',
  country_code: '',
  extended_address: '',
  locality: '',
  postal_code: '',
  street_address: ''
});

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}}/addresses/actions/validate',
  headers: {'content-type': 'application/json'},
  data: {
    administrative_area: '',
    country_code: '',
    extended_address: '',
    locality: '',
    postal_code: '',
    street_address: ''
  }
};

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

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

const url = '{{baseUrl}}/addresses/actions/validate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"administrative_area":"","country_code":"","extended_address":"","locality":"","postal_code":"","street_address":""}'
};

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 = @{ @"administrative_area": @"",
                              @"country_code": @"",
                              @"extended_address": @"",
                              @"locality": @"",
                              @"postal_code": @"",
                              @"street_address": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/addresses/actions/validate"]
                                                       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}}/addresses/actions/validate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\n}" in

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

 "{{baseUrl}}/addresses/actions/validate",
  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([
    'administrative_area' => '',
    'country_code' => '',
    'extended_address' => '',
    'locality' => '',
    'postal_code' => '',
    'street_address' => ''
  ]),
  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}}/addresses/actions/validate', [
  'body' => '{
  "administrative_area": "",
  "country_code": "",
  "extended_address": "",
  "locality": "",
  "postal_code": "",
  "street_address": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/addresses/actions/validate');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'administrative_area' => '',
  'country_code' => '',
  'extended_address' => '',
  'locality' => '',
  'postal_code' => '',
  'street_address' => ''
]));

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

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

append(json_encode([
  'administrative_area' => '',
  'country_code' => '',
  'extended_address' => '',
  'locality' => '',
  'postal_code' => '',
  'street_address' => ''
]));
$request->setRequestUrl('{{baseUrl}}/addresses/actions/validate');
$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}}/addresses/actions/validate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "administrative_area": "",
  "country_code": "",
  "extended_address": "",
  "locality": "",
  "postal_code": "",
  "street_address": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/addresses/actions/validate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "administrative_area": "",
  "country_code": "",
  "extended_address": "",
  "locality": "",
  "postal_code": "",
  "street_address": ""
}'

import http.client

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

payload = "{\n  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\n}"

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

conn.request("POST", "/baseUrl/addresses/actions/validate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/addresses/actions/validate"

payload = {
    "administrative_area": "",
    "country_code": "",
    "extended_address": "",
    "locality": "",
    "postal_code": "",
    "street_address": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/addresses/actions/validate"

payload <- "{\n  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\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}}/addresses/actions/validate")

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  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\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/addresses/actions/validate') do |req|
  req.body = "{\n  \"administrative_area\": \"\",\n  \"country_code\": \"\",\n  \"extended_address\": \"\",\n  \"locality\": \"\",\n  \"postal_code\": \"\",\n  \"street_address\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "administrative_area": "",
        "country_code": "",
        "extended_address": "",
        "locality": "",
        "postal_code": "",
        "street_address": ""
    });

    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 '{
  "administrative_area": "",
  "country_code": "",
  "extended_address": "",
  "locality": "",
  "postal_code": "",
  "street_address": ""
}' |  \
  http POST {{baseUrl}}/addresses/actions/validate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "administrative_area": "",\n  "country_code": "",\n  "extended_address": "",\n  "locality": "",\n  "postal_code": "",\n  "street_address": ""\n}' \
  --output-document \
  - {{baseUrl}}/addresses/actions/validate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "administrative_area": "",
  "country_code": "",
  "extended_address": "",
  "locality": "",
  "postal_code": "",
  "street_address": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/addresses/actions/validate")! 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}}/authentication_providers");

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  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/authentication_providers" {:content-type :json
                                                                     :form-params {:active false
                                                                                   :name ""
                                                                                   :settings {:idp_cert_fingerprint ""
                                                                                              :idp_cert_fingerprint_algorithm ""
                                                                                              :idp_entity_id ""
                                                                                              :idp_sso_target_url ""}
                                                                                   :settings_url ""
                                                                                   :short_name ""}})

require "http/client"

url = "{{baseUrl}}/authentication_providers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_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}}/authentication_providers"),
    Content = new StringContent("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_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}}/authentication_providers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_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/authentication_providers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 226

{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/authentication_providers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication_providers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_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  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/authentication_providers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/authentication_providers")
  .header("content-type", "application/json")
  .body("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  active: false,
  name: '',
  settings: {
    idp_cert_fingerprint: '',
    idp_cert_fingerprint_algorithm: '',
    idp_entity_id: '',
    idp_sso_target_url: ''
  },
  settings_url: '',
  short_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}}/authentication_providers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/authentication_providers',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    name: '',
    settings: {
      idp_cert_fingerprint: '',
      idp_cert_fingerprint_algorithm: '',
      idp_entity_id: '',
      idp_sso_target_url: ''
    },
    settings_url: '',
    short_name: ''
  }
};

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

const url = '{{baseUrl}}/authentication_providers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"name":"","settings":{"idp_cert_fingerprint":"","idp_cert_fingerprint_algorithm":"","idp_entity_id":"","idp_sso_target_url":""},"settings_url":"","short_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}}/authentication_providers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "active": false,\n  "name": "",\n  "settings": {\n    "idp_cert_fingerprint": "",\n    "idp_cert_fingerprint_algorithm": "",\n    "idp_entity_id": "",\n    "idp_sso_target_url": ""\n  },\n  "settings_url": "",\n  "short_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  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/authentication_providers")
  .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/authentication_providers',
  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({
  active: false,
  name: '',
  settings: {
    idp_cert_fingerprint: '',
    idp_cert_fingerprint_algorithm: '',
    idp_entity_id: '',
    idp_sso_target_url: ''
  },
  settings_url: '',
  short_name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/authentication_providers',
  headers: {'content-type': 'application/json'},
  body: {
    active: false,
    name: '',
    settings: {
      idp_cert_fingerprint: '',
      idp_cert_fingerprint_algorithm: '',
      idp_entity_id: '',
      idp_sso_target_url: ''
    },
    settings_url: '',
    short_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}}/authentication_providers');

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

req.type('json');
req.send({
  active: false,
  name: '',
  settings: {
    idp_cert_fingerprint: '',
    idp_cert_fingerprint_algorithm: '',
    idp_entity_id: '',
    idp_sso_target_url: ''
  },
  settings_url: '',
  short_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}}/authentication_providers',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    name: '',
    settings: {
      idp_cert_fingerprint: '',
      idp_cert_fingerprint_algorithm: '',
      idp_entity_id: '',
      idp_sso_target_url: ''
    },
    settings_url: '',
    short_name: ''
  }
};

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

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

const url = '{{baseUrl}}/authentication_providers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"name":"","settings":{"idp_cert_fingerprint":"","idp_cert_fingerprint_algorithm":"","idp_entity_id":"","idp_sso_target_url":""},"settings_url":"","short_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 = @{ @"active": @NO,
                              @"name": @"",
                              @"settings": @{ @"idp_cert_fingerprint": @"", @"idp_cert_fingerprint_algorithm": @"", @"idp_entity_id": @"", @"idp_sso_target_url": @"" },
                              @"settings_url": @"",
                              @"short_name": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authentication_providers"]
                                                       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}}/authentication_providers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}" in

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

 "{{baseUrl}}/authentication_providers",
  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([
    'active' => null,
    'name' => '',
    'settings' => [
        'idp_cert_fingerprint' => '',
        'idp_cert_fingerprint_algorithm' => '',
        'idp_entity_id' => '',
        'idp_sso_target_url' => ''
    ],
    'settings_url' => '',
    'short_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}}/authentication_providers', [
  'body' => '{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/authentication_providers');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'active' => null,
  'name' => '',
  'settings' => [
    'idp_cert_fingerprint' => '',
    'idp_cert_fingerprint_algorithm' => '',
    'idp_entity_id' => '',
    'idp_sso_target_url' => ''
  ],
  'settings_url' => '',
  'short_name' => ''
]));

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

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

append(json_encode([
  'active' => null,
  'name' => '',
  'settings' => [
    'idp_cert_fingerprint' => '',
    'idp_cert_fingerprint_algorithm' => '',
    'idp_entity_id' => '',
    'idp_sso_target_url' => ''
  ],
  'settings_url' => '',
  'short_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/authentication_providers');
$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}}/authentication_providers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication_providers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}'

import http.client

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

payload = "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/authentication_providers"

payload = {
    "active": False,
    "name": "",
    "settings": {
        "idp_cert_fingerprint": "",
        "idp_cert_fingerprint_algorithm": "",
        "idp_entity_id": "",
        "idp_sso_target_url": ""
    },
    "settings_url": "",
    "short_name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_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}}/authentication_providers")

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  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_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/authentication_providers') do |req|
  req.body = "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "active": false,
        "name": "",
        "settings": json!({
            "idp_cert_fingerprint": "",
            "idp_cert_fingerprint_algorithm": "",
            "idp_entity_id": "",
            "idp_sso_target_url": ""
        }),
        "settings_url": "",
        "short_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 '{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}' |  \
  http POST {{baseUrl}}/authentication_providers \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "active": false,\n  "name": "",\n  "settings": {\n    "idp_cert_fingerprint": "",\n    "idp_cert_fingerprint_algorithm": "",\n    "idp_entity_id": "",\n    "idp_sso_target_url": ""\n  },\n  "settings_url": "",\n  "short_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/authentication_providers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "active": false,
  "name": "",
  "settings": [
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  ],
  "settings_url": "",
  "short_name": ""
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/authentication_providers/:id")

require "http/client"

url = "{{baseUrl}}/authentication_providers/:id"

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}}/authentication_providers/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/authentication_providers/:id"

	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/authentication_providers/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication_providers/:id"))
    .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}}/authentication_providers/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/authentication_providers/:id")
  .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}}/authentication_providers/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/authentication_providers/:id'
};

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

const url = '{{baseUrl}}/authentication_providers/:id';
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}}/authentication_providers/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authentication_providers/:id',
  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}}/authentication_providers/:id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/authentication_providers/:id');

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}}/authentication_providers/:id'
};

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

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

const url = '{{baseUrl}}/authentication_providers/:id';
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}}/authentication_providers/:id"]
                                                       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}}/authentication_providers/:id" in

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

 "{{baseUrl}}/authentication_providers/:id",
  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}}/authentication_providers/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/authentication_providers/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication_providers/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/authentication_providers/:id")

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

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

import requests

url = "{{baseUrl}}/authentication_providers/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication_providers/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication_providers/:id")

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/authentication_providers/:id') do |req|
end

puts response.status
puts response.body

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

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

    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}}/authentication_providers/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/authentication_providers/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authentication_providers/:id")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/authentication_providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/authentication_providers")

require "http/client"

url = "{{baseUrl}}/authentication_providers"

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

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

var client = new RestClient("{{baseUrl}}/authentication_providers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/authentication_providers HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/authentication_providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/authentication_providers")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/authentication_providers');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/authentication_providers'};

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

const url = '{{baseUrl}}/authentication_providers';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/authentication_providers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/authentication_providers")
  .get()
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/authentication_providers'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/authentication_providers');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/authentication_providers'};

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

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

const url = '{{baseUrl}}/authentication_providers';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/authentication_providers" in

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

 "{{baseUrl}}/authentication_providers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/authentication_providers');

echo $response->getBody();

setUrl('{{baseUrl}}/authentication_providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/authentication_providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/authentication_providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication_providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/authentication_providers")

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

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

import requests

url = "{{baseUrl}}/authentication_providers"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/authentication_providers') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/authentication_providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/authentication_providers

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/authentication_providers/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/authentication_providers/:id")

require "http/client"

url = "{{baseUrl}}/authentication_providers/:id"

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

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

var client = new RestClient("{{baseUrl}}/authentication_providers/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/authentication_providers/:id"

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

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

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

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

}

GET /baseUrl/authentication_providers/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/authentication_providers/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/authentication_providers/:id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/authentication_providers/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/authentication_providers/:id'};

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

const url = '{{baseUrl}}/authentication_providers/:id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/authentication_providers/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/authentication_providers/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authentication_providers/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/authentication_providers/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/authentication_providers/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/authentication_providers/:id'};

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

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

const url = '{{baseUrl}}/authentication_providers/:id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authentication_providers/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/authentication_providers/:id" in

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

 "{{baseUrl}}/authentication_providers/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/authentication_providers/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/authentication_providers/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/authentication_providers/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/authentication_providers/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication_providers/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/authentication_providers/:id")

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

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

import requests

url = "{{baseUrl}}/authentication_providers/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication_providers/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication_providers/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/authentication_providers/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/authentication_providers/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/authentication_providers/:id

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/authentication_providers/:id");

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  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/authentication_providers/:id" {:content-type :json
                                                                          :form-params {:active false
                                                                                        :name ""
                                                                                        :settings {:idp_cert_fingerprint ""
                                                                                                   :idp_cert_fingerprint_algorithm ""
                                                                                                   :idp_entity_id ""
                                                                                                   :idp_sso_target_url ""}
                                                                                        :settings_url ""
                                                                                        :short_name ""}})

require "http/client"

url = "{{baseUrl}}/authentication_providers/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/authentication_providers/:id"),
    Content = new StringContent("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_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}}/authentication_providers/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/authentication_providers/:id"

	payload := strings.NewReader("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}")

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

}

PATCH /baseUrl/authentication_providers/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 226

{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/authentication_providers/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authentication_providers/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_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  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/authentication_providers/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/authentication_providers/:id")
  .header("content-type", "application/json")
  .body("{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  active: false,
  name: '',
  settings: {
    idp_cert_fingerprint: '',
    idp_cert_fingerprint_algorithm: '',
    idp_entity_id: '',
    idp_sso_target_url: ''
  },
  settings_url: '',
  short_name: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/authentication_providers/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/authentication_providers/:id',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    name: '',
    settings: {
      idp_cert_fingerprint: '',
      idp_cert_fingerprint_algorithm: '',
      idp_entity_id: '',
      idp_sso_target_url: ''
    },
    settings_url: '',
    short_name: ''
  }
};

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

const url = '{{baseUrl}}/authentication_providers/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"name":"","settings":{"idp_cert_fingerprint":"","idp_cert_fingerprint_algorithm":"","idp_entity_id":"","idp_sso_target_url":""},"settings_url":"","short_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}}/authentication_providers/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "active": false,\n  "name": "",\n  "settings": {\n    "idp_cert_fingerprint": "",\n    "idp_cert_fingerprint_algorithm": "",\n    "idp_entity_id": "",\n    "idp_sso_target_url": ""\n  },\n  "settings_url": "",\n  "short_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  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/authentication_providers/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authentication_providers/:id',
  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({
  active: false,
  name: '',
  settings: {
    idp_cert_fingerprint: '',
    idp_cert_fingerprint_algorithm: '',
    idp_entity_id: '',
    idp_sso_target_url: ''
  },
  settings_url: '',
  short_name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/authentication_providers/:id',
  headers: {'content-type': 'application/json'},
  body: {
    active: false,
    name: '',
    settings: {
      idp_cert_fingerprint: '',
      idp_cert_fingerprint_algorithm: '',
      idp_entity_id: '',
      idp_sso_target_url: ''
    },
    settings_url: '',
    short_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('PATCH', '{{baseUrl}}/authentication_providers/:id');

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

req.type('json');
req.send({
  active: false,
  name: '',
  settings: {
    idp_cert_fingerprint: '',
    idp_cert_fingerprint_algorithm: '',
    idp_entity_id: '',
    idp_sso_target_url: ''
  },
  settings_url: '',
  short_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: 'PATCH',
  url: '{{baseUrl}}/authentication_providers/:id',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    name: '',
    settings: {
      idp_cert_fingerprint: '',
      idp_cert_fingerprint_algorithm: '',
      idp_entity_id: '',
      idp_sso_target_url: ''
    },
    settings_url: '',
    short_name: ''
  }
};

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

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

const url = '{{baseUrl}}/authentication_providers/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"name":"","settings":{"idp_cert_fingerprint":"","idp_cert_fingerprint_algorithm":"","idp_entity_id":"","idp_sso_target_url":""},"settings_url":"","short_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 = @{ @"active": @NO,
                              @"name": @"",
                              @"settings": @{ @"idp_cert_fingerprint": @"", @"idp_cert_fingerprint_algorithm": @"", @"idp_entity_id": @"", @"idp_sso_target_url": @"" },
                              @"settings_url": @"",
                              @"short_name": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authentication_providers/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/authentication_providers/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}" in

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

 "{{baseUrl}}/authentication_providers/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'active' => null,
    'name' => '',
    'settings' => [
        'idp_cert_fingerprint' => '',
        'idp_cert_fingerprint_algorithm' => '',
        'idp_entity_id' => '',
        'idp_sso_target_url' => ''
    ],
    'settings_url' => '',
    'short_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('PATCH', '{{baseUrl}}/authentication_providers/:id', [
  'body' => '{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/authentication_providers/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'active' => null,
  'name' => '',
  'settings' => [
    'idp_cert_fingerprint' => '',
    'idp_cert_fingerprint_algorithm' => '',
    'idp_entity_id' => '',
    'idp_sso_target_url' => ''
  ],
  'settings_url' => '',
  'short_name' => ''
]));

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

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

append(json_encode([
  'active' => null,
  'name' => '',
  'settings' => [
    'idp_cert_fingerprint' => '',
    'idp_cert_fingerprint_algorithm' => '',
    'idp_entity_id' => '',
    'idp_sso_target_url' => ''
  ],
  'settings_url' => '',
  'short_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/authentication_providers/:id');
$request->setRequestMethod('PATCH');
$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}}/authentication_providers/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/authentication_providers/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}'

import http.client

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

payload = "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/authentication_providers/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/authentication_providers/:id"

payload = {
    "active": False,
    "name": "",
    "settings": {
        "idp_cert_fingerprint": "",
        "idp_cert_fingerprint_algorithm": "",
        "idp_entity_id": "",
        "idp_sso_target_url": ""
    },
    "settings_url": "",
    "short_name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/authentication_providers/:id"

payload <- "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authentication_providers/:id")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_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.patch('/baseUrl/authentication_providers/:id') do |req|
  req.body = "{\n  \"active\": false,\n  \"name\": \"\",\n  \"settings\": {\n    \"idp_cert_fingerprint\": \"\",\n    \"idp_cert_fingerprint_algorithm\": \"\",\n    \"idp_entity_id\": \"\",\n    \"idp_sso_target_url\": \"\"\n  },\n  \"settings_url\": \"\",\n  \"short_name\": \"\"\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "active": false,
        "name": "",
        "settings": json!({
            "idp_cert_fingerprint": "",
            "idp_cert_fingerprint_algorithm": "",
            "idp_entity_id": "",
            "idp_sso_target_url": ""
        }),
        "settings_url": "",
        "short_name": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "active": false,
  "name": "",
  "settings": {
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  },
  "settings_url": "",
  "short_name": ""
}' |  \
  http PATCH {{baseUrl}}/authentication_providers/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "active": false,\n  "name": "",\n  "settings": {\n    "idp_cert_fingerprint": "",\n    "idp_cert_fingerprint_algorithm": "",\n    "idp_entity_id": "",\n    "idp_sso_target_url": ""\n  },\n  "settings_url": "",\n  "short_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/authentication_providers/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "active": false,
  "name": "",
  "settings": [
    "idp_cert_fingerprint": "",
    "idp_cert_fingerprint_algorithm": "",
    "idp_entity_id": "",
    "idp_sso_target_url": ""
  ],
  "settings_url": "",
  "short_name": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/balance");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/balance")

require "http/client"

url = "{{baseUrl}}/balance"

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

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

var client = new RestClient("{{baseUrl}}/balance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/balance HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/balance")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/balance")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/balance');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/balance'};

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

const url = '{{baseUrl}}/balance';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/balance',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/balance")
  .get()
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/balance'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/balance');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/balance'};

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

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

const url = '{{baseUrl}}/balance';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/balance" in

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

 "{{baseUrl}}/balance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/balance');

echo $response->getBody();

setUrl('{{baseUrl}}/balance');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/balance');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/balance' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/balance' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/balance")

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

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

import requests

url = "{{baseUrl}}/balance"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/balance') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/balance

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/balance

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/billing_groups")

require "http/client"

url = "{{baseUrl}}/billing_groups"

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

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

var client = new RestClient("{{baseUrl}}/billing_groups");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

}

POST /baseUrl/billing_groups HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/billing_groups")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/billing_groups")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/billing_groups');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/billing_groups'};

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

const url = '{{baseUrl}}/billing_groups';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/billing_groups',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/billing_groups")
  .post(null)
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/billing_groups'};

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

  console.log(body);
});

const unirest = require('unirest');

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

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}}/billing_groups'};

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

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

const url = '{{baseUrl}}/billing_groups';
const options = {method: 'POST'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/billing_groups" in

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

 "{{baseUrl}}/billing_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 => "",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/billing_groups');

echo $response->getBody();

setUrl('{{baseUrl}}/billing_groups');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/billing_groups');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/billing_groups' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing_groups' -Method POST 

import http.client

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

payload = ""

conn.request("POST", "/baseUrl/billing_groups", payload)

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

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

import requests

url = "{{baseUrl}}/billing_groups"

payload = ""

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

print(response.json())

library(httr)

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

payload <- ""

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/billing_groups

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/billing_groups

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/billing_groups/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/billing_groups/:id")

require "http/client"

url = "{{baseUrl}}/billing_groups/:id"

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}}/billing_groups/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/billing_groups/:id"

	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/billing_groups/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/billing_groups/:id"))
    .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}}/billing_groups/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/billing_groups/:id")
  .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}}/billing_groups/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/billing_groups/:id'};

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

const url = '{{baseUrl}}/billing_groups/:id';
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}}/billing_groups/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/billing_groups/:id',
  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}}/billing_groups/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/billing_groups/:id');

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}}/billing_groups/:id'};

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

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

const url = '{{baseUrl}}/billing_groups/:id';
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}}/billing_groups/:id"]
                                                       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}}/billing_groups/:id" in

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

 "{{baseUrl}}/billing_groups/:id",
  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}}/billing_groups/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/billing_groups/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing_groups/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/billing_groups/:id")

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

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

import requests

url = "{{baseUrl}}/billing_groups/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/billing_groups/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/billing_groups/:id")

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/billing_groups/:id') do |req|
end

puts response.status
puts response.body

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

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

    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}}/billing_groups/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/billing_groups/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/billing_groups/:id")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/billing_groups");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/billing_groups")

require "http/client"

url = "{{baseUrl}}/billing_groups"

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

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

var client = new RestClient("{{baseUrl}}/billing_groups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/billing_groups HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/billing_groups")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/billing_groups")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/billing_groups');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/billing_groups'};

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

const url = '{{baseUrl}}/billing_groups';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/billing_groups',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/billing_groups")
  .get()
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/billing_groups'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/billing_groups');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/billing_groups'};

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

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

const url = '{{baseUrl}}/billing_groups';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/billing_groups" in

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

 "{{baseUrl}}/billing_groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/billing_groups');

echo $response->getBody();

setUrl('{{baseUrl}}/billing_groups');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/billing_groups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/billing_groups' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing_groups' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/billing_groups")

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

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

import requests

url = "{{baseUrl}}/billing_groups"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/billing_groups') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/billing_groups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/billing_groups

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/billing_groups/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/billing_groups/:id")

require "http/client"

url = "{{baseUrl}}/billing_groups/:id"

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

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

var client = new RestClient("{{baseUrl}}/billing_groups/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/billing_groups/:id"

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

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

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

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

}

GET /baseUrl/billing_groups/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/billing_groups/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/billing_groups/:id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/billing_groups/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/billing_groups/:id'};

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

const url = '{{baseUrl}}/billing_groups/:id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/billing_groups/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/billing_groups/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/billing_groups/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/billing_groups/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/billing_groups/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/billing_groups/:id'};

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

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

const url = '{{baseUrl}}/billing_groups/:id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/billing_groups/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/billing_groups/:id" in

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

 "{{baseUrl}}/billing_groups/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/billing_groups/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/billing_groups/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/billing_groups/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/billing_groups/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing_groups/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/billing_groups/:id")

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

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

import requests

url = "{{baseUrl}}/billing_groups/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/billing_groups/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/billing_groups/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/billing_groups/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/billing_groups/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/billing_groups/:id

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/billing_groups/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/billing_groups/:id")

require "http/client"

url = "{{baseUrl}}/billing_groups/:id"

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

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

var client = new RestClient("{{baseUrl}}/billing_groups/:id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/billing_groups/:id"

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

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

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

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

}

PATCH /baseUrl/billing_groups/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/billing_groups/:id")
  .patch(null)
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/billing_groups/:id")
  .asString();

const data = null;

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

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

xhr.open('PATCH', '{{baseUrl}}/billing_groups/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PATCH', url: '{{baseUrl}}/billing_groups/:id'};

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

const url = '{{baseUrl}}/billing_groups/:id';
const options = {method: 'PATCH'};

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}}/billing_groups/:id',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/billing_groups/:id")
  .patch(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/billing_groups/:id',
  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: 'PATCH', url: '{{baseUrl}}/billing_groups/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/billing_groups/:id');

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

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

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

const options = {method: 'PATCH', url: '{{baseUrl}}/billing_groups/:id'};

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

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

const url = '{{baseUrl}}/billing_groups/:id';
const options = {method: 'PATCH'};

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}}/billing_groups/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

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}}/billing_groups/:id" in

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

 "{{baseUrl}}/billing_groups/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/billing_groups/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/billing_groups/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

setRequestUrl('{{baseUrl}}/billing_groups/:id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/billing_groups/:id' -Method PATCH 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing_groups/:id' -Method PATCH 

import http.client

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

payload = ""

conn.request("PATCH", "/baseUrl/billing_groups/:id", payload)

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

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

import requests

url = "{{baseUrl}}/billing_groups/:id"

payload = ""

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/billing_groups/:id"

payload <- ""

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/billing_groups/:id")

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

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

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

require 'faraday'

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

response = conn.patch('/baseUrl/billing_groups/:id') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http PATCH {{baseUrl}}/billing_groups/:id

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/billing_groups/:id

import Foundation

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

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}}/actions/bulk/telephony_credentials");

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  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/actions/bulk/telephony_credentials" {:content-type :json
                                                                               :form-params {:amount 0
                                                                                             :connection_id ""
                                                                                             :name ""
                                                                                             :tag ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/actions/bulk/telephony_credentials"

	payload := strings.NewReader("{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\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/actions/bulk/telephony_credentials HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 67

{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/actions/bulk/telephony_credentials")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/actions/bulk/telephony_credentials")
  .header("content-type", "application/json")
  .body("{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  amount: 0,
  connection_id: '',
  name: '',
  tag: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/actions/bulk/telephony_credentials',
  headers: {'content-type': 'application/json'},
  data: {amount: 0, connection_id: '', name: '', tag: ''}
};

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

const url = '{{baseUrl}}/actions/bulk/telephony_credentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":0,"connection_id":"","name":"","tag":""}'
};

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}}/actions/bulk/telephony_credentials',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "amount": 0,\n  "connection_id": "",\n  "name": "",\n  "tag": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/actions/bulk/telephony_credentials")
  .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/actions/bulk/telephony_credentials',
  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({amount: 0, connection_id: '', name: '', tag: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/actions/bulk/telephony_credentials',
  headers: {'content-type': 'application/json'},
  body: {amount: 0, connection_id: '', name: '', tag: ''},
  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}}/actions/bulk/telephony_credentials');

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

req.type('json');
req.send({
  amount: 0,
  connection_id: '',
  name: '',
  tag: ''
});

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}}/actions/bulk/telephony_credentials',
  headers: {'content-type': 'application/json'},
  data: {amount: 0, connection_id: '', name: '', tag: ''}
};

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

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

const url = '{{baseUrl}}/actions/bulk/telephony_credentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":0,"connection_id":"","name":"","tag":""}'
};

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 = @{ @"amount": @0,
                              @"connection_id": @"",
                              @"name": @"",
                              @"tag": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/actions/bulk/telephony_credentials"]
                                                       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}}/actions/bulk/telephony_credentials" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}" in

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

 "{{baseUrl}}/actions/bulk/telephony_credentials",
  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([
    'amount' => 0,
    'connection_id' => '',
    'name' => '',
    'tag' => ''
  ]),
  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}}/actions/bulk/telephony_credentials', [
  'body' => '{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/actions/bulk/telephony_credentials');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'amount' => 0,
  'connection_id' => '',
  'name' => '',
  'tag' => ''
]));

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

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

append(json_encode([
  'amount' => 0,
  'connection_id' => '',
  'name' => '',
  'tag' => ''
]));
$request->setRequestUrl('{{baseUrl}}/actions/bulk/telephony_credentials');
$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}}/actions/bulk/telephony_credentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/actions/bulk/telephony_credentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}'

import http.client

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

payload = "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}"

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

conn.request("POST", "/baseUrl/actions/bulk/telephony_credentials", payload, headers)

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

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

import requests

url = "{{baseUrl}}/actions/bulk/telephony_credentials"

payload = {
    "amount": 0,
    "connection_id": "",
    "name": "",
    "tag": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/actions/bulk/telephony_credentials"

payload <- "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\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}}/actions/bulk/telephony_credentials")

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  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\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/actions/bulk/telephony_credentials') do |req|
  req.body = "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "amount": 0,
        "connection_id": "",
        "name": "",
        "tag": ""
    });

    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 '{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}' |  \
  http POST {{baseUrl}}/actions/bulk/telephony_credentials \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "amount": 0,\n  "connection_id": "",\n  "name": "",\n  "tag": ""\n}' \
  --output-document \
  - {{baseUrl}}/actions/bulk/telephony_credentials

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/actions/bulk/telephony_credentials")! 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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/actions/bulk/telephony_credentials" {:query-params {:filter[tag] ""}})

require "http/client"

url = "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D="

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}}/actions/bulk/telephony_credentials?filter%5Btag%5D="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D="

	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/actions/bulk/telephony_credentials?filter%5Btag%5D= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D="))
    .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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")
  .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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/actions/bulk/telephony_credentials',
  params: {'filter[tag]': ''}
};

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

const url = '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=';
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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/actions/bulk/telephony_credentials?filter%5Btag%5D=',
  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}}/actions/bulk/telephony_credentials',
  qs: {'filter[tag]': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/actions/bulk/telephony_credentials');

req.query({
  'filter[tag]': ''
});

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}}/actions/bulk/telephony_credentials',
  params: {'filter[tag]': ''}
};

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

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

const url = '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=';
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}}/actions/bulk/telephony_credentials?filter%5Btag%5D="]
                                                       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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=" in

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

 "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=",
  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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=');

echo $response->getBody();

setUrl('{{baseUrl}}/actions/bulk/telephony_credentials');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

setRequestUrl('{{baseUrl}}/actions/bulk/telephony_credentials');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'filter[tag]' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/actions/bulk/telephony_credentials?filter%5Btag%5D=")

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

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

import requests

url = "{{baseUrl}}/actions/bulk/telephony_credentials"

querystring = {"filter[tag]":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/actions/bulk/telephony_credentials"

queryString <- list(filter[tag] = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")

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/actions/bulk/telephony_credentials') do |req|
  req.params['filter[tag]'] = ''
end

puts response.status
puts response.body

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

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

    let querystring = [
        ("filter[tag]", ""),
    ];

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

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

    dbg!(results);
}

http DELETE '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/actions/:action/telephony_credentials" {:query-params {:filter[tag] ""}})

require "http/client"

url = "{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D="

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

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

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

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

}

POST /baseUrl/actions/:action/telephony_credentials?filter%5Btag%5D= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/actions/:action/telephony_credentials',
  params: {'filter[tag]': ''}
};

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

const url = '{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/actions/:action/telephony_credentials?filter%5Btag%5D=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/actions/:action/telephony_credentials',
  qs: {'filter[tag]': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/actions/:action/telephony_credentials');

req.query({
  'filter[tag]': ''
});

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}}/actions/:action/telephony_credentials',
  params: {'filter[tag]': ''}
};

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

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

const url = '{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=" in

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

 "{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=');

echo $response->getBody();

setUrl('{{baseUrl}}/actions/:action/telephony_credentials');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/actions/:action/telephony_credentials');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'filter[tag]' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/actions/:action/telephony_credentials?filter%5Btag%5D=")

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

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

import requests

url = "{{baseUrl}}/actions/:action/telephony_credentials"

querystring = {"filter[tag]":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/actions/:action/telephony_credentials"

queryString <- list(filter[tag] = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/actions/:action/telephony_credentials') do |req|
  req.params['filter[tag]'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("filter[tag]", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

http POST '{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/actions/:action/telephony_credentials?filter%5Btag%5D=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=");

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  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/actions/bulk/telephony_credentials" {:query-params {:filter[tag] ""}
                                                                                :content-type :json
                                                                                :form-params {:amount 0
                                                                                              :connection_id ""
                                                                                              :name ""
                                                                                              :tag ""}})

require "http/client"

url = "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D="),
    Content = new StringContent("{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D="

	payload := strings.NewReader("{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}")

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

}

PATCH /baseUrl/actions/bulk/telephony_credentials?filter%5Btag%5D= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 67

{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D="))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\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  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")
  .header("content-type", "application/json")
  .body("{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  amount: 0,
  connection_id: '',
  name: '',
  tag: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/actions/bulk/telephony_credentials',
  params: {'filter[tag]': ''},
  headers: {'content-type': 'application/json'},
  data: {amount: 0, connection_id: '', name: '', tag: ''}
};

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

const url = '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"amount":0,"connection_id":"","name":"","tag":""}'
};

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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "amount": 0,\n  "connection_id": "",\n  "name": "",\n  "tag": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/actions/bulk/telephony_credentials?filter%5Btag%5D=',
  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({amount: 0, connection_id: '', name: '', tag: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/actions/bulk/telephony_credentials',
  qs: {'filter[tag]': ''},
  headers: {'content-type': 'application/json'},
  body: {amount: 0, connection_id: '', name: '', tag: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/actions/bulk/telephony_credentials');

req.query({
  'filter[tag]': ''
});

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

req.type('json');
req.send({
  amount: 0,
  connection_id: '',
  name: '',
  tag: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/actions/bulk/telephony_credentials',
  params: {'filter[tag]': ''},
  headers: {'content-type': 'application/json'},
  data: {amount: 0, connection_id: '', name: '', tag: ''}
};

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

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

const url = '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"amount":0,"connection_id":"","name":"","tag":""}'
};

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 = @{ @"amount": @0,
                              @"connection_id": @"",
                              @"name": @"",
                              @"tag": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}" in

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

 "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'amount' => 0,
    'connection_id' => '',
    'name' => '',
    'tag' => ''
  ]),
  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('PATCH', '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=', [
  'body' => '{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/actions/bulk/telephony_credentials');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'amount' => 0,
  'connection_id' => '',
  'name' => '',
  'tag' => ''
]));

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

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

append(json_encode([
  'amount' => 0,
  'connection_id' => '',
  'name' => '',
  'tag' => ''
]));
$request->setRequestUrl('{{baseUrl}}/actions/bulk/telephony_credentials');
$request->setRequestMethod('PATCH');
$request->setBody($body);

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

$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}}/actions/bulk/telephony_credentials?filter%5Btag%5D=' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}'

import http.client

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

payload = "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/actions/bulk/telephony_credentials?filter%5Btag%5D=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/actions/bulk/telephony_credentials"

querystring = {"filter[tag]":""}

payload = {
    "amount": 0,
    "connection_id": "",
    "name": "",
    "tag": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/actions/bulk/telephony_credentials"

queryString <- list(filter[tag] = "")

payload <- "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\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.patch('/baseUrl/actions/bulk/telephony_credentials') do |req|
  req.params['filter[tag]'] = ''
  req.body = "{\n  \"amount\": 0,\n  \"connection_id\": \"\",\n  \"name\": \"\",\n  \"tag\": \"\"\n}"
end

puts response.status
puts response.body

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

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

    let querystring = [
        ("filter[tag]", ""),
    ];

    let payload = json!({
        "amount": 0,
        "connection_id": "",
        "name": "",
        "tag": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
}' |  \
  http PATCH '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=' \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "amount": 0,\n  "connection_id": "",\n  "name": "",\n  "tag": ""\n}' \
  --output-document \
  - '{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D='

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "amount": 0,
  "connection_id": "",
  "name": "",
  "tag": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/actions/bulk/telephony_credentials?filter%5Btag%5D=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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}}/calls/:call_control_id/actions/answer");

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  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/calls/:call_control_id/actions/answer" {:content-type :json
                                                                                  :form-params {:billing_group_id ""
                                                                                                :client_state ""
                                                                                                :command_id ""
                                                                                                :webhook_url ""
                                                                                                :webhook_url_method ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/answer"

	payload := strings.NewReader("{\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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/calls/:call_control_id/actions/answer HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 119

{
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "webhook_url": "",
  "webhook_url_method": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/answer")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/answer")
  .header("content-type", "application/json")
  .body("{\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  billing_group_id: '',
  client_state: '',
  command_id: '',
  webhook_url: '',
  webhook_url_method: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/answer');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/answer',
  headers: {'content-type': 'application/json'},
  data: {
    billing_group_id: '',
    client_state: '',
    command_id: '',
    webhook_url: '',
    webhook_url_method: ''
  }
};

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

const url = '{{baseUrl}}/calls/:call_control_id/actions/answer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"billing_group_id":"","client_state":"","command_id":"","webhook_url":"","webhook_url_method":""}'
};

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}}/calls/:call_control_id/actions/answer',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "billing_group_id": "",\n  "client_state": "",\n  "command_id": "",\n  "webhook_url": "",\n  "webhook_url_method": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/answer")
  .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/calls/:call_control_id/actions/answer',
  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({
  billing_group_id: '',
  client_state: '',
  command_id: '',
  webhook_url: '',
  webhook_url_method: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/answer',
  headers: {'content-type': 'application/json'},
  body: {
    billing_group_id: '',
    client_state: '',
    command_id: '',
    webhook_url: '',
    webhook_url_method: ''
  },
  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}}/calls/:call_control_id/actions/answer');

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

req.type('json');
req.send({
  billing_group_id: '',
  client_state: '',
  command_id: '',
  webhook_url: '',
  webhook_url_method: ''
});

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}}/calls/:call_control_id/actions/answer',
  headers: {'content-type': 'application/json'},
  data: {
    billing_group_id: '',
    client_state: '',
    command_id: '',
    webhook_url: '',
    webhook_url_method: ''
  }
};

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

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

const url = '{{baseUrl}}/calls/:call_control_id/actions/answer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"billing_group_id":"","client_state":"","command_id":"","webhook_url":"","webhook_url_method":""}'
};

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 = @{ @"billing_group_id": @"",
                              @"client_state": @"",
                              @"command_id": @"",
                              @"webhook_url": @"",
                              @"webhook_url_method": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/answer"]
                                                       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}}/calls/:call_control_id/actions/answer" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}" in

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

 "{{baseUrl}}/calls/:call_control_id/actions/answer",
  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([
    'billing_group_id' => '',
    'client_state' => '',
    'command_id' => '',
    'webhook_url' => '',
    'webhook_url_method' => ''
  ]),
  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}}/calls/:call_control_id/actions/answer', [
  'body' => '{
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "webhook_url": "",
  "webhook_url_method": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/answer');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'billing_group_id' => '',
  'client_state' => '',
  'command_id' => '',
  'webhook_url' => '',
  'webhook_url_method' => ''
]));

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

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

append(json_encode([
  'billing_group_id' => '',
  'client_state' => '',
  'command_id' => '',
  'webhook_url' => '',
  'webhook_url_method' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/answer');
$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}}/calls/:call_control_id/actions/answer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "webhook_url": "",
  "webhook_url_method": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/answer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "webhook_url": "",
  "webhook_url_method": ""
}'

import http.client

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

payload = "{\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}"

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

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/answer", payload, headers)

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

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

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/answer"

payload = {
    "billing_group_id": "",
    "client_state": "",
    "command_id": "",
    "webhook_url": "",
    "webhook_url_method": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/answer"

payload <- "{\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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}}/calls/:call_control_id/actions/answer")

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  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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/calls/:call_control_id/actions/answer') do |req|
  req.body = "{\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "billing_group_id": "",
        "client_state": "",
        "command_id": "",
        "webhook_url": "",
        "webhook_url_method": ""
    });

    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 '{
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "webhook_url": "",
  "webhook_url_method": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/answer \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "billing_group_id": "",\n  "client_state": "",\n  "command_id": "",\n  "webhook_url": "",\n  "webhook_url_method": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/answer

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "webhook_url": "",
  "webhook_url_method": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/answer")! 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}}/calls/:call_control_id/actions/bridge");

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  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/calls/:call_control_id/actions/bridge" {:content-type :json
                                                                                  :form-params {:call_control_id ""
                                                                                                :client_state ""
                                                                                                :command_id ""
                                                                                                :park_after_unbridge ""
                                                                                                :queue ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/bridge"

	payload := strings.NewReader("{\n  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\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/calls/:call_control_id/actions/bridge HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 113

{
  "call_control_id": "",
  "client_state": "",
  "command_id": "",
  "park_after_unbridge": "",
  "queue": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/bridge")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/bridge")
  .header("content-type", "application/json")
  .body("{\n  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  call_control_id: '',
  client_state: '',
  command_id: '',
  park_after_unbridge: '',
  queue: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/bridge');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/bridge',
  headers: {'content-type': 'application/json'},
  data: {
    call_control_id: '',
    client_state: '',
    command_id: '',
    park_after_unbridge: '',
    queue: ''
  }
};

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

const url = '{{baseUrl}}/calls/:call_control_id/actions/bridge';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"call_control_id":"","client_state":"","command_id":"","park_after_unbridge":"","queue":""}'
};

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}}/calls/:call_control_id/actions/bridge',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "call_control_id": "",\n  "client_state": "",\n  "command_id": "",\n  "park_after_unbridge": "",\n  "queue": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/bridge")
  .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/calls/:call_control_id/actions/bridge',
  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({
  call_control_id: '',
  client_state: '',
  command_id: '',
  park_after_unbridge: '',
  queue: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/bridge',
  headers: {'content-type': 'application/json'},
  body: {
    call_control_id: '',
    client_state: '',
    command_id: '',
    park_after_unbridge: '',
    queue: ''
  },
  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}}/calls/:call_control_id/actions/bridge');

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

req.type('json');
req.send({
  call_control_id: '',
  client_state: '',
  command_id: '',
  park_after_unbridge: '',
  queue: ''
});

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}}/calls/:call_control_id/actions/bridge',
  headers: {'content-type': 'application/json'},
  data: {
    call_control_id: '',
    client_state: '',
    command_id: '',
    park_after_unbridge: '',
    queue: ''
  }
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/bridge';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"call_control_id":"","client_state":"","command_id":"","park_after_unbridge":"","queue":""}'
};

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 = @{ @"call_control_id": @"",
                              @"client_state": @"",
                              @"command_id": @"",
                              @"park_after_unbridge": @"",
                              @"queue": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/bridge"]
                                                       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}}/calls/:call_control_id/actions/bridge" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/bridge",
  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([
    'call_control_id' => '',
    'client_state' => '',
    'command_id' => '',
    'park_after_unbridge' => '',
    'queue' => ''
  ]),
  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}}/calls/:call_control_id/actions/bridge', [
  'body' => '{
  "call_control_id": "",
  "client_state": "",
  "command_id": "",
  "park_after_unbridge": "",
  "queue": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/bridge');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'call_control_id' => '',
  'client_state' => '',
  'command_id' => '',
  'park_after_unbridge' => '',
  'queue' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'call_control_id' => '',
  'client_state' => '',
  'command_id' => '',
  'park_after_unbridge' => '',
  'queue' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/bridge');
$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}}/calls/:call_control_id/actions/bridge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "call_control_id": "",
  "client_state": "",
  "command_id": "",
  "park_after_unbridge": "",
  "queue": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/bridge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "call_control_id": "",
  "client_state": "",
  "command_id": "",
  "park_after_unbridge": "",
  "queue": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/bridge", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/bridge"

payload = {
    "call_control_id": "",
    "client_state": "",
    "command_id": "",
    "park_after_unbridge": "",
    "queue": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/bridge"

payload <- "{\n  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\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}}/calls/:call_control_id/actions/bridge")

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  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\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/calls/:call_control_id/actions/bridge') do |req|
  req.body = "{\n  \"call_control_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"park_after_unbridge\": \"\",\n  \"queue\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/bridge";

    let payload = json!({
        "call_control_id": "",
        "client_state": "",
        "command_id": "",
        "park_after_unbridge": "",
        "queue": ""
    });

    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 '{
  "call_control_id": "",
  "client_state": "",
  "command_id": "",
  "park_after_unbridge": "",
  "queue": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/bridge \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "call_control_id": "",\n  "client_state": "",\n  "command_id": "",\n  "park_after_unbridge": "",\n  "queue": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/bridge

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "call_control_id": "",
  "client_state": "",
  "command_id": "",
  "park_after_unbridge": "",
  "queue": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/bridge")! 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}}/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  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls" {:content-type :json
                                                  :form-params {:answering_machine_detection ""
                                                                :answering_machine_detection_config {:after_greeting_silence_millis 0
                                                                                                     :between_words_silence_millis 0
                                                                                                     :greeting_duration_millis 0
                                                                                                     :greeting_silence_duration_millis 0
                                                                                                     :greeting_total_analysis_time_millis 0
                                                                                                     :initial_silence_millis 0
                                                                                                     :maximum_number_of_words 0
                                                                                                     :maximum_word_length_millis 0
                                                                                                     :silence_threshold 0
                                                                                                     :total_analysis_time_millis 0}
                                                                :audio_url ""
                                                                :billing_group_id ""
                                                                :client_state ""
                                                                :command_id ""
                                                                :connection_id ""
                                                                :custom_headers [{:name ""
                                                                                  :value ""}]
                                                                :from ""
                                                                :from_display_name ""
                                                                :link_to ""
                                                                :media_name ""
                                                                :sip_auth_password ""
                                                                :sip_auth_username ""
                                                                :time_limit_secs 0
                                                                :timeout_secs 0
                                                                :to ""
                                                                :webhook_url ""
                                                                :webhook_url_method ""}})

require "http/client"

url = "{{baseUrl}}/calls"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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}}/calls"),
    Content = new StringContent("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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}}/calls");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls"

	payload := strings.NewReader("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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/calls HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 880

{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "connection_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "link_to": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls")
  .header("content-type", "application/json")
  .body("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  answering_machine_detection: '',
  answering_machine_detection_config: {
    after_greeting_silence_millis: 0,
    between_words_silence_millis: 0,
    greeting_duration_millis: 0,
    greeting_silence_duration_millis: 0,
    greeting_total_analysis_time_millis: 0,
    initial_silence_millis: 0,
    maximum_number_of_words: 0,
    maximum_word_length_millis: 0,
    silence_threshold: 0,
    total_analysis_time_millis: 0
  },
  audio_url: '',
  billing_group_id: '',
  client_state: '',
  command_id: '',
  connection_id: '',
  custom_headers: [
    {
      name: '',
      value: ''
    }
  ],
  from: '',
  from_display_name: '',
  link_to: '',
  media_name: '',
  sip_auth_password: '',
  sip_auth_username: '',
  time_limit_secs: 0,
  timeout_secs: 0,
  to: '',
  webhook_url: '',
  webhook_url_method: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls',
  headers: {'content-type': 'application/json'},
  data: {
    answering_machine_detection: '',
    answering_machine_detection_config: {
      after_greeting_silence_millis: 0,
      between_words_silence_millis: 0,
      greeting_duration_millis: 0,
      greeting_silence_duration_millis: 0,
      greeting_total_analysis_time_millis: 0,
      initial_silence_millis: 0,
      maximum_number_of_words: 0,
      maximum_word_length_millis: 0,
      silence_threshold: 0,
      total_analysis_time_millis: 0
    },
    audio_url: '',
    billing_group_id: '',
    client_state: '',
    command_id: '',
    connection_id: '',
    custom_headers: [{name: '', value: ''}],
    from: '',
    from_display_name: '',
    link_to: '',
    media_name: '',
    sip_auth_password: '',
    sip_auth_username: '',
    time_limit_secs: 0,
    timeout_secs: 0,
    to: '',
    webhook_url: '',
    webhook_url_method: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"answering_machine_detection":"","answering_machine_detection_config":{"after_greeting_silence_millis":0,"between_words_silence_millis":0,"greeting_duration_millis":0,"greeting_silence_duration_millis":0,"greeting_total_analysis_time_millis":0,"initial_silence_millis":0,"maximum_number_of_words":0,"maximum_word_length_millis":0,"silence_threshold":0,"total_analysis_time_millis":0},"audio_url":"","billing_group_id":"","client_state":"","command_id":"","connection_id":"","custom_headers":[{"name":"","value":""}],"from":"","from_display_name":"","link_to":"","media_name":"","sip_auth_password":"","sip_auth_username":"","time_limit_secs":0,"timeout_secs":0,"to":"","webhook_url":"","webhook_url_method":""}'
};

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}}/calls',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "answering_machine_detection": "",\n  "answering_machine_detection_config": {\n    "after_greeting_silence_millis": 0,\n    "between_words_silence_millis": 0,\n    "greeting_duration_millis": 0,\n    "greeting_silence_duration_millis": 0,\n    "greeting_total_analysis_time_millis": 0,\n    "initial_silence_millis": 0,\n    "maximum_number_of_words": 0,\n    "maximum_word_length_millis": 0,\n    "silence_threshold": 0,\n    "total_analysis_time_millis": 0\n  },\n  "audio_url": "",\n  "billing_group_id": "",\n  "client_state": "",\n  "command_id": "",\n  "connection_id": "",\n  "custom_headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "from": "",\n  "from_display_name": "",\n  "link_to": "",\n  "media_name": "",\n  "sip_auth_password": "",\n  "sip_auth_username": "",\n  "time_limit_secs": 0,\n  "timeout_secs": 0,\n  "to": "",\n  "webhook_url": "",\n  "webhook_url_method": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/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/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({
  answering_machine_detection: '',
  answering_machine_detection_config: {
    after_greeting_silence_millis: 0,
    between_words_silence_millis: 0,
    greeting_duration_millis: 0,
    greeting_silence_duration_millis: 0,
    greeting_total_analysis_time_millis: 0,
    initial_silence_millis: 0,
    maximum_number_of_words: 0,
    maximum_word_length_millis: 0,
    silence_threshold: 0,
    total_analysis_time_millis: 0
  },
  audio_url: '',
  billing_group_id: '',
  client_state: '',
  command_id: '',
  connection_id: '',
  custom_headers: [{name: '', value: ''}],
  from: '',
  from_display_name: '',
  link_to: '',
  media_name: '',
  sip_auth_password: '',
  sip_auth_username: '',
  time_limit_secs: 0,
  timeout_secs: 0,
  to: '',
  webhook_url: '',
  webhook_url_method: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls',
  headers: {'content-type': 'application/json'},
  body: {
    answering_machine_detection: '',
    answering_machine_detection_config: {
      after_greeting_silence_millis: 0,
      between_words_silence_millis: 0,
      greeting_duration_millis: 0,
      greeting_silence_duration_millis: 0,
      greeting_total_analysis_time_millis: 0,
      initial_silence_millis: 0,
      maximum_number_of_words: 0,
      maximum_word_length_millis: 0,
      silence_threshold: 0,
      total_analysis_time_millis: 0
    },
    audio_url: '',
    billing_group_id: '',
    client_state: '',
    command_id: '',
    connection_id: '',
    custom_headers: [{name: '', value: ''}],
    from: '',
    from_display_name: '',
    link_to: '',
    media_name: '',
    sip_auth_password: '',
    sip_auth_username: '',
    time_limit_secs: 0,
    timeout_secs: 0,
    to: '',
    webhook_url: '',
    webhook_url_method: ''
  },
  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}}/calls');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  answering_machine_detection: '',
  answering_machine_detection_config: {
    after_greeting_silence_millis: 0,
    between_words_silence_millis: 0,
    greeting_duration_millis: 0,
    greeting_silence_duration_millis: 0,
    greeting_total_analysis_time_millis: 0,
    initial_silence_millis: 0,
    maximum_number_of_words: 0,
    maximum_word_length_millis: 0,
    silence_threshold: 0,
    total_analysis_time_millis: 0
  },
  audio_url: '',
  billing_group_id: '',
  client_state: '',
  command_id: '',
  connection_id: '',
  custom_headers: [
    {
      name: '',
      value: ''
    }
  ],
  from: '',
  from_display_name: '',
  link_to: '',
  media_name: '',
  sip_auth_password: '',
  sip_auth_username: '',
  time_limit_secs: 0,
  timeout_secs: 0,
  to: '',
  webhook_url: '',
  webhook_url_method: ''
});

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}}/calls',
  headers: {'content-type': 'application/json'},
  data: {
    answering_machine_detection: '',
    answering_machine_detection_config: {
      after_greeting_silence_millis: 0,
      between_words_silence_millis: 0,
      greeting_duration_millis: 0,
      greeting_silence_duration_millis: 0,
      greeting_total_analysis_time_millis: 0,
      initial_silence_millis: 0,
      maximum_number_of_words: 0,
      maximum_word_length_millis: 0,
      silence_threshold: 0,
      total_analysis_time_millis: 0
    },
    audio_url: '',
    billing_group_id: '',
    client_state: '',
    command_id: '',
    connection_id: '',
    custom_headers: [{name: '', value: ''}],
    from: '',
    from_display_name: '',
    link_to: '',
    media_name: '',
    sip_auth_password: '',
    sip_auth_username: '',
    time_limit_secs: 0,
    timeout_secs: 0,
    to: '',
    webhook_url: '',
    webhook_url_method: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"answering_machine_detection":"","answering_machine_detection_config":{"after_greeting_silence_millis":0,"between_words_silence_millis":0,"greeting_duration_millis":0,"greeting_silence_duration_millis":0,"greeting_total_analysis_time_millis":0,"initial_silence_millis":0,"maximum_number_of_words":0,"maximum_word_length_millis":0,"silence_threshold":0,"total_analysis_time_millis":0},"audio_url":"","billing_group_id":"","client_state":"","command_id":"","connection_id":"","custom_headers":[{"name":"","value":""}],"from":"","from_display_name":"","link_to":"","media_name":"","sip_auth_password":"","sip_auth_username":"","time_limit_secs":0,"timeout_secs":0,"to":"","webhook_url":"","webhook_url_method":""}'
};

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 = @{ @"answering_machine_detection": @"",
                              @"answering_machine_detection_config": @{ @"after_greeting_silence_millis": @0, @"between_words_silence_millis": @0, @"greeting_duration_millis": @0, @"greeting_silence_duration_millis": @0, @"greeting_total_analysis_time_millis": @0, @"initial_silence_millis": @0, @"maximum_number_of_words": @0, @"maximum_word_length_millis": @0, @"silence_threshold": @0, @"total_analysis_time_millis": @0 },
                              @"audio_url": @"",
                              @"billing_group_id": @"",
                              @"client_state": @"",
                              @"command_id": @"",
                              @"connection_id": @"",
                              @"custom_headers": @[ @{ @"name": @"", @"value": @"" } ],
                              @"from": @"",
                              @"from_display_name": @"",
                              @"link_to": @"",
                              @"media_name": @"",
                              @"sip_auth_password": @"",
                              @"sip_auth_username": @"",
                              @"time_limit_secs": @0,
                              @"timeout_secs": @0,
                              @"to": @"",
                              @"webhook_url": @"",
                              @"webhook_url_method": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/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}}/calls" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/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([
    'answering_machine_detection' => '',
    'answering_machine_detection_config' => [
        'after_greeting_silence_millis' => 0,
        'between_words_silence_millis' => 0,
        'greeting_duration_millis' => 0,
        'greeting_silence_duration_millis' => 0,
        'greeting_total_analysis_time_millis' => 0,
        'initial_silence_millis' => 0,
        'maximum_number_of_words' => 0,
        'maximum_word_length_millis' => 0,
        'silence_threshold' => 0,
        'total_analysis_time_millis' => 0
    ],
    'audio_url' => '',
    'billing_group_id' => '',
    'client_state' => '',
    'command_id' => '',
    'connection_id' => '',
    'custom_headers' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'from' => '',
    'from_display_name' => '',
    'link_to' => '',
    'media_name' => '',
    'sip_auth_password' => '',
    'sip_auth_username' => '',
    'time_limit_secs' => 0,
    'timeout_secs' => 0,
    'to' => '',
    'webhook_url' => '',
    'webhook_url_method' => ''
  ]),
  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}}/calls', [
  'body' => '{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "connection_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "link_to": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'answering_machine_detection' => '',
  'answering_machine_detection_config' => [
    'after_greeting_silence_millis' => 0,
    'between_words_silence_millis' => 0,
    'greeting_duration_millis' => 0,
    'greeting_silence_duration_millis' => 0,
    'greeting_total_analysis_time_millis' => 0,
    'initial_silence_millis' => 0,
    'maximum_number_of_words' => 0,
    'maximum_word_length_millis' => 0,
    'silence_threshold' => 0,
    'total_analysis_time_millis' => 0
  ],
  'audio_url' => '',
  'billing_group_id' => '',
  'client_state' => '',
  'command_id' => '',
  'connection_id' => '',
  'custom_headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'from' => '',
  'from_display_name' => '',
  'link_to' => '',
  'media_name' => '',
  'sip_auth_password' => '',
  'sip_auth_username' => '',
  'time_limit_secs' => 0,
  'timeout_secs' => 0,
  'to' => '',
  'webhook_url' => '',
  'webhook_url_method' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'answering_machine_detection' => '',
  'answering_machine_detection_config' => [
    'after_greeting_silence_millis' => 0,
    'between_words_silence_millis' => 0,
    'greeting_duration_millis' => 0,
    'greeting_silence_duration_millis' => 0,
    'greeting_total_analysis_time_millis' => 0,
    'initial_silence_millis' => 0,
    'maximum_number_of_words' => 0,
    'maximum_word_length_millis' => 0,
    'silence_threshold' => 0,
    'total_analysis_time_millis' => 0
  ],
  'audio_url' => '',
  'billing_group_id' => '',
  'client_state' => '',
  'command_id' => '',
  'connection_id' => '',
  'custom_headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'from' => '',
  'from_display_name' => '',
  'link_to' => '',
  'media_name' => '',
  'sip_auth_password' => '',
  'sip_auth_username' => '',
  'time_limit_secs' => 0,
  'timeout_secs' => 0,
  'to' => '',
  'webhook_url' => '',
  'webhook_url_method' => ''
]));
$request->setRequestUrl('{{baseUrl}}/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}}/calls' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "connection_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "link_to": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "connection_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "link_to": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls"

payload = {
    "answering_machine_detection": "",
    "answering_machine_detection_config": {
        "after_greeting_silence_millis": 0,
        "between_words_silence_millis": 0,
        "greeting_duration_millis": 0,
        "greeting_silence_duration_millis": 0,
        "greeting_total_analysis_time_millis": 0,
        "initial_silence_millis": 0,
        "maximum_number_of_words": 0,
        "maximum_word_length_millis": 0,
        "silence_threshold": 0,
        "total_analysis_time_millis": 0
    },
    "audio_url": "",
    "billing_group_id": "",
    "client_state": "",
    "command_id": "",
    "connection_id": "",
    "custom_headers": [
        {
            "name": "",
            "value": ""
        }
    ],
    "from": "",
    "from_display_name": "",
    "link_to": "",
    "media_name": "",
    "sip_auth_password": "",
    "sip_auth_username": "",
    "time_limit_secs": 0,
    "timeout_secs": 0,
    "to": "",
    "webhook_url": "",
    "webhook_url_method": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls"

payload <- "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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}}/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  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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/calls') do |req|
  req.body = "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"billing_group_id\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"connection_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"link_to\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls";

    let payload = json!({
        "answering_machine_detection": "",
        "answering_machine_detection_config": json!({
            "after_greeting_silence_millis": 0,
            "between_words_silence_millis": 0,
            "greeting_duration_millis": 0,
            "greeting_silence_duration_millis": 0,
            "greeting_total_analysis_time_millis": 0,
            "initial_silence_millis": 0,
            "maximum_number_of_words": 0,
            "maximum_word_length_millis": 0,
            "silence_threshold": 0,
            "total_analysis_time_millis": 0
        }),
        "audio_url": "",
        "billing_group_id": "",
        "client_state": "",
        "command_id": "",
        "connection_id": "",
        "custom_headers": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "from": "",
        "from_display_name": "",
        "link_to": "",
        "media_name": "",
        "sip_auth_password": "",
        "sip_auth_username": "",
        "time_limit_secs": 0,
        "timeout_secs": 0,
        "to": "",
        "webhook_url": "",
        "webhook_url_method": ""
    });

    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 '{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "connection_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "link_to": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}' |  \
  http POST {{baseUrl}}/calls \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "answering_machine_detection": "",\n  "answering_machine_detection_config": {\n    "after_greeting_silence_millis": 0,\n    "between_words_silence_millis": 0,\n    "greeting_duration_millis": 0,\n    "greeting_silence_duration_millis": 0,\n    "greeting_total_analysis_time_millis": 0,\n    "initial_silence_millis": 0,\n    "maximum_number_of_words": 0,\n    "maximum_word_length_millis": 0,\n    "silence_threshold": 0,\n    "total_analysis_time_millis": 0\n  },\n  "audio_url": "",\n  "billing_group_id": "",\n  "client_state": "",\n  "command_id": "",\n  "connection_id": "",\n  "custom_headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "from": "",\n  "from_display_name": "",\n  "link_to": "",\n  "media_name": "",\n  "sip_auth_password": "",\n  "sip_auth_username": "",\n  "time_limit_secs": 0,\n  "timeout_secs": 0,\n  "to": "",\n  "webhook_url": "",\n  "webhook_url_method": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "answering_machine_detection": "",
  "answering_machine_detection_config": [
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  ],
  "audio_url": "",
  "billing_group_id": "",
  "client_state": "",
  "command_id": "",
  "connection_id": "",
  "custom_headers": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "from": "",
  "from_display_name": "",
  "link_to": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/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}}/calls/:call_control_id/actions/enqueue");

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/enqueue" {:content-type :json
                                                                                   :form-params {:client_state ""
                                                                                                 :command_id ""
                                                                                                 :max_size 0
                                                                                                 :max_wait_time_secs 0
                                                                                                 :queue_name ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/enqueue"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_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}}/calls/:call_control_id/actions/enqueue"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_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}}/calls/:call_control_id/actions/enqueue");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/enqueue"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_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/calls/:call_control_id/actions/enqueue HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 108

{
  "client_state": "",
  "command_id": "",
  "max_size": 0,
  "max_wait_time_secs": 0,
  "queue_name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/enqueue")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/enqueue"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/enqueue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/enqueue")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: '',
  max_size: 0,
  max_wait_time_secs: 0,
  queue_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}}/calls/:call_control_id/actions/enqueue');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/enqueue',
  headers: {'content-type': 'application/json'},
  data: {
    client_state: '',
    command_id: '',
    max_size: 0,
    max_wait_time_secs: 0,
    queue_name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/enqueue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","max_size":0,"max_wait_time_secs":0,"queue_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}}/calls/:call_control_id/actions/enqueue',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": "",\n  "max_size": 0,\n  "max_wait_time_secs": 0,\n  "queue_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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/enqueue")
  .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/calls/:call_control_id/actions/enqueue',
  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({
  client_state: '',
  command_id: '',
  max_size: 0,
  max_wait_time_secs: 0,
  queue_name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/enqueue',
  headers: {'content-type': 'application/json'},
  body: {
    client_state: '',
    command_id: '',
    max_size: 0,
    max_wait_time_secs: 0,
    queue_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}}/calls/:call_control_id/actions/enqueue');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: '',
  max_size: 0,
  max_wait_time_secs: 0,
  queue_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}}/calls/:call_control_id/actions/enqueue',
  headers: {'content-type': 'application/json'},
  data: {
    client_state: '',
    command_id: '',
    max_size: 0,
    max_wait_time_secs: 0,
    queue_name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/enqueue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","max_size":0,"max_wait_time_secs":0,"queue_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 = @{ @"client_state": @"",
                              @"command_id": @"",
                              @"max_size": @0,
                              @"max_wait_time_secs": @0,
                              @"queue_name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/enqueue"]
                                                       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}}/calls/:call_control_id/actions/enqueue" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/enqueue",
  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([
    'client_state' => '',
    'command_id' => '',
    'max_size' => 0,
    'max_wait_time_secs' => 0,
    'queue_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}}/calls/:call_control_id/actions/enqueue', [
  'body' => '{
  "client_state": "",
  "command_id": "",
  "max_size": 0,
  "max_wait_time_secs": 0,
  "queue_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/enqueue');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => '',
  'max_size' => 0,
  'max_wait_time_secs' => 0,
  'queue_name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => '',
  'max_size' => 0,
  'max_wait_time_secs' => 0,
  'queue_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/enqueue');
$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}}/calls/:call_control_id/actions/enqueue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "max_size": 0,
  "max_wait_time_secs": 0,
  "queue_name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/enqueue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "max_size": 0,
  "max_wait_time_secs": 0,
  "queue_name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/enqueue", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/enqueue"

payload = {
    "client_state": "",
    "command_id": "",
    "max_size": 0,
    "max_wait_time_secs": 0,
    "queue_name": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/enqueue"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_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}}/calls/:call_control_id/actions/enqueue")

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_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/calls/:call_control_id/actions/enqueue') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"max_size\": 0,\n  \"max_wait_time_secs\": 0,\n  \"queue_name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/enqueue";

    let payload = json!({
        "client_state": "",
        "command_id": "",
        "max_size": 0,
        "max_wait_time_secs": 0,
        "queue_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 '{
  "client_state": "",
  "command_id": "",
  "max_size": 0,
  "max_wait_time_secs": 0,
  "queue_name": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/enqueue \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": "",\n  "max_size": 0,\n  "max_wait_time_secs": 0,\n  "queue_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/enqueue

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": "",
  "max_size": 0,
  "max_wait_time_secs": 0,
  "queue_name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/enqueue")! 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}}/calls/:call_control_id/actions/fork_start");

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/fork_start" {:content-type :json
                                                                                      :form-params {:client_state ""
                                                                                                    :command_id ""
                                                                                                    :rx ""
                                                                                                    :stream_type ""
                                                                                                    :target ""
                                                                                                    :tx ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/fork_start"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\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}}/calls/:call_control_id/actions/fork_start"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\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}}/calls/:call_control_id/actions/fork_start");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/fork_start"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\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/calls/:call_control_id/actions/fork_start HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 105

{
  "client_state": "",
  "command_id": "",
  "rx": "",
  "stream_type": "",
  "target": "",
  "tx": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/fork_start")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/fork_start"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/fork_start")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/fork_start")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: '',
  rx: '',
  stream_type: '',
  target: '',
  tx: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/fork_start');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/fork_start',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: '', rx: '', stream_type: '', target: '', tx: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/fork_start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","rx":"","stream_type":"","target":"","tx":""}'
};

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}}/calls/:call_control_id/actions/fork_start',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": "",\n  "rx": "",\n  "stream_type": "",\n  "target": "",\n  "tx": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/fork_start")
  .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/calls/:call_control_id/actions/fork_start',
  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({client_state: '', command_id: '', rx: '', stream_type: '', target: '', tx: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/fork_start',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: '', rx: '', stream_type: '', target: '', tx: ''},
  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}}/calls/:call_control_id/actions/fork_start');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: '',
  rx: '',
  stream_type: '',
  target: '',
  tx: ''
});

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}}/calls/:call_control_id/actions/fork_start',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: '', rx: '', stream_type: '', target: '', tx: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/fork_start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","rx":"","stream_type":"","target":"","tx":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"",
                              @"rx": @"",
                              @"stream_type": @"",
                              @"target": @"",
                              @"tx": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/fork_start"]
                                                       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}}/calls/:call_control_id/actions/fork_start" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/fork_start",
  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([
    'client_state' => '',
    'command_id' => '',
    'rx' => '',
    'stream_type' => '',
    'target' => '',
    'tx' => ''
  ]),
  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}}/calls/:call_control_id/actions/fork_start', [
  'body' => '{
  "client_state": "",
  "command_id": "",
  "rx": "",
  "stream_type": "",
  "target": "",
  "tx": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/fork_start');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => '',
  'rx' => '',
  'stream_type' => '',
  'target' => '',
  'tx' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => '',
  'rx' => '',
  'stream_type' => '',
  'target' => '',
  'tx' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/fork_start');
$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}}/calls/:call_control_id/actions/fork_start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "rx": "",
  "stream_type": "",
  "target": "",
  "tx": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/fork_start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "rx": "",
  "stream_type": "",
  "target": "",
  "tx": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/fork_start", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/fork_start"

payload = {
    "client_state": "",
    "command_id": "",
    "rx": "",
    "stream_type": "",
    "target": "",
    "tx": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/fork_start"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\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}}/calls/:call_control_id/actions/fork_start")

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\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/calls/:call_control_id/actions/fork_start') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"rx\": \"\",\n  \"stream_type\": \"\",\n  \"target\": \"\",\n  \"tx\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/fork_start";

    let payload = json!({
        "client_state": "",
        "command_id": "",
        "rx": "",
        "stream_type": "",
        "target": "",
        "tx": ""
    });

    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 '{
  "client_state": "",
  "command_id": "",
  "rx": "",
  "stream_type": "",
  "target": "",
  "tx": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/fork_start \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": "",\n  "rx": "",\n  "stream_type": "",\n  "target": "",\n  "tx": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/fork_start

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": "",
  "rx": "",
  "stream_type": "",
  "target": "",
  "tx": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/fork_start")! 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}}/calls/:call_control_id/actions/fork_stop");

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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/fork_stop" {:content-type :json
                                                                                     :form-params {:client_state ""
                                                                                                   :command_id ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/fork_stop"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/fork_stop"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/fork_stop");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/fork_stop"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/fork_stop HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "client_state": "",
  "command_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/fork_stop")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/fork_stop"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/fork_stop")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/fork_stop")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/fork_stop');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/fork_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/fork_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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}}/calls/:call_control_id/actions/fork_stop',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/fork_stop")
  .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/calls/:call_control_id/actions/fork_stop',
  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({client_state: '', command_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/fork_stop',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: ''},
  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}}/calls/:call_control_id/actions/fork_stop');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: ''
});

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}}/calls/:call_control_id/actions/fork_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/fork_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/fork_stop"]
                                                       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}}/calls/:call_control_id/actions/fork_stop" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/fork_stop",
  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([
    'client_state' => '',
    'command_id' => ''
  ]),
  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}}/calls/:call_control_id/actions/fork_stop', [
  'body' => '{
  "client_state": "",
  "command_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/fork_stop');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/fork_stop');
$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}}/calls/:call_control_id/actions/fork_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/fork_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/fork_stop", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/fork_stop"

payload = {
    "client_state": "",
    "command_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/fork_stop"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/fork_stop")

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  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/fork_stop') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/fork_stop";

    let payload = json!({
        "client_state": "",
        "command_id": ""
    });

    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 '{
  "client_state": "",
  "command_id": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/fork_stop \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/fork_stop

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/fork_stop")! 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}}/calls/:call_control_id/actions/gather_stop");

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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/gather_stop" {:content-type :json
                                                                                       :form-params {:client_state ""
                                                                                                     :command_id ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/gather_stop"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/gather_stop"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/gather_stop");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/gather_stop"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/gather_stop HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "client_state": "",
  "command_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/gather_stop")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/gather_stop"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/gather_stop")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/gather_stop")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/gather_stop');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/gather_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/gather_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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}}/calls/:call_control_id/actions/gather_stop',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/gather_stop")
  .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/calls/:call_control_id/actions/gather_stop',
  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({client_state: '', command_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/gather_stop',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: ''},
  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}}/calls/:call_control_id/actions/gather_stop');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: ''
});

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}}/calls/:call_control_id/actions/gather_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/gather_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/gather_stop"]
                                                       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}}/calls/:call_control_id/actions/gather_stop" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/gather_stop",
  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([
    'client_state' => '',
    'command_id' => ''
  ]),
  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}}/calls/:call_control_id/actions/gather_stop', [
  'body' => '{
  "client_state": "",
  "command_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/gather_stop');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/gather_stop');
$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}}/calls/:call_control_id/actions/gather_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/gather_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/gather_stop", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/gather_stop"

payload = {
    "client_state": "",
    "command_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/gather_stop"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/gather_stop")

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  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/gather_stop') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/gather_stop";

    let payload = json!({
        "client_state": "",
        "command_id": ""
    });

    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 '{
  "client_state": "",
  "command_id": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/gather_stop \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/gather_stop

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/gather_stop")! 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}}/calls/:call_control_id/actions/gather_using_audio");

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  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio" {:content-type :json
                                                                                              :form-params {:audio_url ""
                                                                                                            :client_state ""
                                                                                                            :command_id ""
                                                                                                            :inter_digit_timeout_millis 0
                                                                                                            :invalid_audio_url ""
                                                                                                            :invalid_media_name ""
                                                                                                            :maximum_digits 0
                                                                                                            :maximum_tries 0
                                                                                                            :media_name ""
                                                                                                            :minimum_digits 0
                                                                                                            :terminating_digit ""
                                                                                                            :timeout_millis 0
                                                                                                            :valid_digits ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\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}}/calls/:call_control_id/actions/gather_using_audio"),
    Content = new StringContent("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\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}}/calls/:call_control_id/actions/gather_using_audio");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio"

	payload := strings.NewReader("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\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/calls/:call_control_id/actions/gather_using_audio HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 313

{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_audio_url": "",
  "invalid_media_name": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "media_name": "",
  "minimum_digits": 0,
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\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  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio")
  .header("content-type", "application/json")
  .body("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  audio_url: '',
  client_state: '',
  command_id: '',
  inter_digit_timeout_millis: 0,
  invalid_audio_url: '',
  invalid_media_name: '',
  maximum_digits: 0,
  maximum_tries: 0,
  media_name: '',
  minimum_digits: 0,
  terminating_digit: '',
  timeout_millis: 0,
  valid_digits: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio',
  headers: {'content-type': 'application/json'},
  data: {
    audio_url: '',
    client_state: '',
    command_id: '',
    inter_digit_timeout_millis: 0,
    invalid_audio_url: '',
    invalid_media_name: '',
    maximum_digits: 0,
    maximum_tries: 0,
    media_name: '',
    minimum_digits: 0,
    terminating_digit: '',
    timeout_millis: 0,
    valid_digits: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"audio_url":"","client_state":"","command_id":"","inter_digit_timeout_millis":0,"invalid_audio_url":"","invalid_media_name":"","maximum_digits":0,"maximum_tries":0,"media_name":"","minimum_digits":0,"terminating_digit":"","timeout_millis":0,"valid_digits":""}'
};

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}}/calls/:call_control_id/actions/gather_using_audio',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "audio_url": "",\n  "client_state": "",\n  "command_id": "",\n  "inter_digit_timeout_millis": 0,\n  "invalid_audio_url": "",\n  "invalid_media_name": "",\n  "maximum_digits": 0,\n  "maximum_tries": 0,\n  "media_name": "",\n  "minimum_digits": 0,\n  "terminating_digit": "",\n  "timeout_millis": 0,\n  "valid_digits": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio")
  .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/calls/:call_control_id/actions/gather_using_audio',
  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({
  audio_url: '',
  client_state: '',
  command_id: '',
  inter_digit_timeout_millis: 0,
  invalid_audio_url: '',
  invalid_media_name: '',
  maximum_digits: 0,
  maximum_tries: 0,
  media_name: '',
  minimum_digits: 0,
  terminating_digit: '',
  timeout_millis: 0,
  valid_digits: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio',
  headers: {'content-type': 'application/json'},
  body: {
    audio_url: '',
    client_state: '',
    command_id: '',
    inter_digit_timeout_millis: 0,
    invalid_audio_url: '',
    invalid_media_name: '',
    maximum_digits: 0,
    maximum_tries: 0,
    media_name: '',
    minimum_digits: 0,
    terminating_digit: '',
    timeout_millis: 0,
    valid_digits: ''
  },
  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}}/calls/:call_control_id/actions/gather_using_audio');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  audio_url: '',
  client_state: '',
  command_id: '',
  inter_digit_timeout_millis: 0,
  invalid_audio_url: '',
  invalid_media_name: '',
  maximum_digits: 0,
  maximum_tries: 0,
  media_name: '',
  minimum_digits: 0,
  terminating_digit: '',
  timeout_millis: 0,
  valid_digits: ''
});

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}}/calls/:call_control_id/actions/gather_using_audio',
  headers: {'content-type': 'application/json'},
  data: {
    audio_url: '',
    client_state: '',
    command_id: '',
    inter_digit_timeout_millis: 0,
    invalid_audio_url: '',
    invalid_media_name: '',
    maximum_digits: 0,
    maximum_tries: 0,
    media_name: '',
    minimum_digits: 0,
    terminating_digit: '',
    timeout_millis: 0,
    valid_digits: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"audio_url":"","client_state":"","command_id":"","inter_digit_timeout_millis":0,"invalid_audio_url":"","invalid_media_name":"","maximum_digits":0,"maximum_tries":0,"media_name":"","minimum_digits":0,"terminating_digit":"","timeout_millis":0,"valid_digits":""}'
};

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 = @{ @"audio_url": @"",
                              @"client_state": @"",
                              @"command_id": @"",
                              @"inter_digit_timeout_millis": @0,
                              @"invalid_audio_url": @"",
                              @"invalid_media_name": @"",
                              @"maximum_digits": @0,
                              @"maximum_tries": @0,
                              @"media_name": @"",
                              @"minimum_digits": @0,
                              @"terminating_digit": @"",
                              @"timeout_millis": @0,
                              @"valid_digits": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio"]
                                                       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}}/calls/:call_control_id/actions/gather_using_audio" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio",
  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([
    'audio_url' => '',
    'client_state' => '',
    'command_id' => '',
    'inter_digit_timeout_millis' => 0,
    'invalid_audio_url' => '',
    'invalid_media_name' => '',
    'maximum_digits' => 0,
    'maximum_tries' => 0,
    'media_name' => '',
    'minimum_digits' => 0,
    'terminating_digit' => '',
    'timeout_millis' => 0,
    'valid_digits' => ''
  ]),
  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}}/calls/:call_control_id/actions/gather_using_audio', [
  'body' => '{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_audio_url": "",
  "invalid_media_name": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "media_name": "",
  "minimum_digits": 0,
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'audio_url' => '',
  'client_state' => '',
  'command_id' => '',
  'inter_digit_timeout_millis' => 0,
  'invalid_audio_url' => '',
  'invalid_media_name' => '',
  'maximum_digits' => 0,
  'maximum_tries' => 0,
  'media_name' => '',
  'minimum_digits' => 0,
  'terminating_digit' => '',
  'timeout_millis' => 0,
  'valid_digits' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'audio_url' => '',
  'client_state' => '',
  'command_id' => '',
  'inter_digit_timeout_millis' => 0,
  'invalid_audio_url' => '',
  'invalid_media_name' => '',
  'maximum_digits' => 0,
  'maximum_tries' => 0,
  'media_name' => '',
  'minimum_digits' => 0,
  'terminating_digit' => '',
  'timeout_millis' => 0,
  'valid_digits' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio');
$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}}/calls/:call_control_id/actions/gather_using_audio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_audio_url": "",
  "invalid_media_name": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "media_name": "",
  "minimum_digits": 0,
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_audio_url": "",
  "invalid_media_name": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "media_name": "",
  "minimum_digits": 0,
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/gather_using_audio", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio"

payload = {
    "audio_url": "",
    "client_state": "",
    "command_id": "",
    "inter_digit_timeout_millis": 0,
    "invalid_audio_url": "",
    "invalid_media_name": "",
    "maximum_digits": 0,
    "maximum_tries": 0,
    "media_name": "",
    "minimum_digits": 0,
    "terminating_digit": "",
    "timeout_millis": 0,
    "valid_digits": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio"

payload <- "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\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}}/calls/:call_control_id/actions/gather_using_audio")

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  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\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/calls/:call_control_id/actions/gather_using_audio') do |req|
  req.body = "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_audio_url\": \"\",\n  \"invalid_media_name\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"media_name\": \"\",\n  \"minimum_digits\": 0,\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio";

    let payload = json!({
        "audio_url": "",
        "client_state": "",
        "command_id": "",
        "inter_digit_timeout_millis": 0,
        "invalid_audio_url": "",
        "invalid_media_name": "",
        "maximum_digits": 0,
        "maximum_tries": 0,
        "media_name": "",
        "minimum_digits": 0,
        "terminating_digit": "",
        "timeout_millis": 0,
        "valid_digits": ""
    });

    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 '{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_audio_url": "",
  "invalid_media_name": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "media_name": "",
  "minimum_digits": 0,
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/gather_using_audio \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "audio_url": "",\n  "client_state": "",\n  "command_id": "",\n  "inter_digit_timeout_millis": 0,\n  "invalid_audio_url": "",\n  "invalid_media_name": "",\n  "maximum_digits": 0,\n  "maximum_tries": 0,\n  "media_name": "",\n  "minimum_digits": 0,\n  "terminating_digit": "",\n  "timeout_millis": 0,\n  "valid_digits": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/gather_using_audio

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_audio_url": "",
  "invalid_media_name": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "media_name": "",
  "minimum_digits": 0,
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/gather_using_audio")! 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}}/calls/:call_control_id/actions/gather_using_speak");

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak" {:content-type :json
                                                                                              :form-params {:client_state ""
                                                                                                            :command_id ""
                                                                                                            :inter_digit_timeout_millis 0
                                                                                                            :invalid_payload ""
                                                                                                            :language ""
                                                                                                            :maximum_digits 0
                                                                                                            :maximum_tries 0
                                                                                                            :minimum_digits 0
                                                                                                            :payload ""
                                                                                                            :payload_type ""
                                                                                                            :service_level ""
                                                                                                            :terminating_digit ""
                                                                                                            :timeout_millis 0
                                                                                                            :valid_digits ""
                                                                                                            :voice ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\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}}/calls/:call_control_id/actions/gather_using_speak"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\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}}/calls/:call_control_id/actions/gather_using_speak");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\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/calls/:call_control_id/actions/gather_using_speak HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 339

{
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_payload": "",
  "language": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "minimum_digits": 0,
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": "",
  "voice": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: '',
  inter_digit_timeout_millis: 0,
  invalid_payload: '',
  language: '',
  maximum_digits: 0,
  maximum_tries: 0,
  minimum_digits: 0,
  payload: '',
  payload_type: '',
  service_level: '',
  terminating_digit: '',
  timeout_millis: 0,
  valid_digits: '',
  voice: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak',
  headers: {'content-type': 'application/json'},
  data: {
    client_state: '',
    command_id: '',
    inter_digit_timeout_millis: 0,
    invalid_payload: '',
    language: '',
    maximum_digits: 0,
    maximum_tries: 0,
    minimum_digits: 0,
    payload: '',
    payload_type: '',
    service_level: '',
    terminating_digit: '',
    timeout_millis: 0,
    valid_digits: '',
    voice: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","inter_digit_timeout_millis":0,"invalid_payload":"","language":"","maximum_digits":0,"maximum_tries":0,"minimum_digits":0,"payload":"","payload_type":"","service_level":"","terminating_digit":"","timeout_millis":0,"valid_digits":"","voice":""}'
};

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}}/calls/:call_control_id/actions/gather_using_speak',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": "",\n  "inter_digit_timeout_millis": 0,\n  "invalid_payload": "",\n  "language": "",\n  "maximum_digits": 0,\n  "maximum_tries": 0,\n  "minimum_digits": 0,\n  "payload": "",\n  "payload_type": "",\n  "service_level": "",\n  "terminating_digit": "",\n  "timeout_millis": 0,\n  "valid_digits": "",\n  "voice": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak")
  .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/calls/:call_control_id/actions/gather_using_speak',
  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({
  client_state: '',
  command_id: '',
  inter_digit_timeout_millis: 0,
  invalid_payload: '',
  language: '',
  maximum_digits: 0,
  maximum_tries: 0,
  minimum_digits: 0,
  payload: '',
  payload_type: '',
  service_level: '',
  terminating_digit: '',
  timeout_millis: 0,
  valid_digits: '',
  voice: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak',
  headers: {'content-type': 'application/json'},
  body: {
    client_state: '',
    command_id: '',
    inter_digit_timeout_millis: 0,
    invalid_payload: '',
    language: '',
    maximum_digits: 0,
    maximum_tries: 0,
    minimum_digits: 0,
    payload: '',
    payload_type: '',
    service_level: '',
    terminating_digit: '',
    timeout_millis: 0,
    valid_digits: '',
    voice: ''
  },
  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}}/calls/:call_control_id/actions/gather_using_speak');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: '',
  inter_digit_timeout_millis: 0,
  invalid_payload: '',
  language: '',
  maximum_digits: 0,
  maximum_tries: 0,
  minimum_digits: 0,
  payload: '',
  payload_type: '',
  service_level: '',
  terminating_digit: '',
  timeout_millis: 0,
  valid_digits: '',
  voice: ''
});

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}}/calls/:call_control_id/actions/gather_using_speak',
  headers: {'content-type': 'application/json'},
  data: {
    client_state: '',
    command_id: '',
    inter_digit_timeout_millis: 0,
    invalid_payload: '',
    language: '',
    maximum_digits: 0,
    maximum_tries: 0,
    minimum_digits: 0,
    payload: '',
    payload_type: '',
    service_level: '',
    terminating_digit: '',
    timeout_millis: 0,
    valid_digits: '',
    voice: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","inter_digit_timeout_millis":0,"invalid_payload":"","language":"","maximum_digits":0,"maximum_tries":0,"minimum_digits":0,"payload":"","payload_type":"","service_level":"","terminating_digit":"","timeout_millis":0,"valid_digits":"","voice":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"",
                              @"inter_digit_timeout_millis": @0,
                              @"invalid_payload": @"",
                              @"language": @"",
                              @"maximum_digits": @0,
                              @"maximum_tries": @0,
                              @"minimum_digits": @0,
                              @"payload": @"",
                              @"payload_type": @"",
                              @"service_level": @"",
                              @"terminating_digit": @"",
                              @"timeout_millis": @0,
                              @"valid_digits": @"",
                              @"voice": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak"]
                                                       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}}/calls/:call_control_id/actions/gather_using_speak" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak",
  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([
    'client_state' => '',
    'command_id' => '',
    'inter_digit_timeout_millis' => 0,
    'invalid_payload' => '',
    'language' => '',
    'maximum_digits' => 0,
    'maximum_tries' => 0,
    'minimum_digits' => 0,
    'payload' => '',
    'payload_type' => '',
    'service_level' => '',
    'terminating_digit' => '',
    'timeout_millis' => 0,
    'valid_digits' => '',
    'voice' => ''
  ]),
  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}}/calls/:call_control_id/actions/gather_using_speak', [
  'body' => '{
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_payload": "",
  "language": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "minimum_digits": 0,
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": "",
  "voice": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => '',
  'inter_digit_timeout_millis' => 0,
  'invalid_payload' => '',
  'language' => '',
  'maximum_digits' => 0,
  'maximum_tries' => 0,
  'minimum_digits' => 0,
  'payload' => '',
  'payload_type' => '',
  'service_level' => '',
  'terminating_digit' => '',
  'timeout_millis' => 0,
  'valid_digits' => '',
  'voice' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => '',
  'inter_digit_timeout_millis' => 0,
  'invalid_payload' => '',
  'language' => '',
  'maximum_digits' => 0,
  'maximum_tries' => 0,
  'minimum_digits' => 0,
  'payload' => '',
  'payload_type' => '',
  'service_level' => '',
  'terminating_digit' => '',
  'timeout_millis' => 0,
  'valid_digits' => '',
  'voice' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak');
$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}}/calls/:call_control_id/actions/gather_using_speak' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_payload": "",
  "language": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "minimum_digits": 0,
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": "",
  "voice": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_payload": "",
  "language": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "minimum_digits": 0,
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": "",
  "voice": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/gather_using_speak", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak"

payload = {
    "client_state": "",
    "command_id": "",
    "inter_digit_timeout_millis": 0,
    "invalid_payload": "",
    "language": "",
    "maximum_digits": 0,
    "maximum_tries": 0,
    "minimum_digits": 0,
    "payload": "",
    "payload_type": "",
    "service_level": "",
    "terminating_digit": "",
    "timeout_millis": 0,
    "valid_digits": "",
    "voice": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\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}}/calls/:call_control_id/actions/gather_using_speak")

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\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/calls/:call_control_id/actions/gather_using_speak') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"inter_digit_timeout_millis\": 0,\n  \"invalid_payload\": \"\",\n  \"language\": \"\",\n  \"maximum_digits\": 0,\n  \"maximum_tries\": 0,\n  \"minimum_digits\": 0,\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"terminating_digit\": \"\",\n  \"timeout_millis\": 0,\n  \"valid_digits\": \"\",\n  \"voice\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak";

    let payload = json!({
        "client_state": "",
        "command_id": "",
        "inter_digit_timeout_millis": 0,
        "invalid_payload": "",
        "language": "",
        "maximum_digits": 0,
        "maximum_tries": 0,
        "minimum_digits": 0,
        "payload": "",
        "payload_type": "",
        "service_level": "",
        "terminating_digit": "",
        "timeout_millis": 0,
        "valid_digits": "",
        "voice": ""
    });

    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 '{
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_payload": "",
  "language": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "minimum_digits": 0,
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": "",
  "voice": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/gather_using_speak \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": "",\n  "inter_digit_timeout_millis": 0,\n  "invalid_payload": "",\n  "language": "",\n  "maximum_digits": 0,\n  "maximum_tries": 0,\n  "minimum_digits": 0,\n  "payload": "",\n  "payload_type": "",\n  "service_level": "",\n  "terminating_digit": "",\n  "timeout_millis": 0,\n  "valid_digits": "",\n  "voice": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/gather_using_speak

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": "",
  "inter_digit_timeout_millis": 0,
  "invalid_payload": "",
  "language": "",
  "maximum_digits": 0,
  "maximum_tries": 0,
  "minimum_digits": 0,
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "terminating_digit": "",
  "timeout_millis": 0,
  "valid_digits": "",
  "voice": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/gather_using_speak")! 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}}/calls/:call_control_id/actions/hangup");

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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/hangup" {:content-type :json
                                                                                  :form-params {:client_state ""
                                                                                                :command_id ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/hangup"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/hangup"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/hangup");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/hangup"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/hangup HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "client_state": "",
  "command_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/hangup")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/hangup"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/hangup")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/hangup")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/hangup');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/hangup',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/hangup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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}}/calls/:call_control_id/actions/hangup',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/hangup")
  .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/calls/:call_control_id/actions/hangup',
  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({client_state: '', command_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/hangup',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: ''},
  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}}/calls/:call_control_id/actions/hangup');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: ''
});

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}}/calls/:call_control_id/actions/hangup',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/hangup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/hangup"]
                                                       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}}/calls/:call_control_id/actions/hangup" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/hangup",
  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([
    'client_state' => '',
    'command_id' => ''
  ]),
  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}}/calls/:call_control_id/actions/hangup', [
  'body' => '{
  "client_state": "",
  "command_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/hangup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/hangup');
$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}}/calls/:call_control_id/actions/hangup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/hangup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/hangup", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/hangup"

payload = {
    "client_state": "",
    "command_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/hangup"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/hangup")

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  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/hangup') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/hangup";

    let payload = json!({
        "client_state": "",
        "command_id": ""
    });

    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 '{
  "client_state": "",
  "command_id": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/hangup \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/hangup

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/hangup")! 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}}/calls/:call_control_id/actions/playback_start");

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  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/playback_start" {:content-type :json
                                                                                          :form-params {:audio_url ""
                                                                                                        :client_state ""
                                                                                                        :command_id ""
                                                                                                        :loop ""
                                                                                                        :media_name ""
                                                                                                        :overlay false
                                                                                                        :stop ""
                                                                                                        :target_legs ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/playback_start"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\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}}/calls/:call_control_id/actions/playback_start"),
    Content = new StringContent("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\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}}/calls/:call_control_id/actions/playback_start");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/playback_start"

	payload := strings.NewReader("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\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/calls/:call_control_id/actions/playback_start HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 152

{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "loop": "",
  "media_name": "",
  "overlay": false,
  "stop": "",
  "target_legs": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/playback_start")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/playback_start"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\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  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/playback_start")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/playback_start")
  .header("content-type", "application/json")
  .body("{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  audio_url: '',
  client_state: '',
  command_id: '',
  loop: '',
  media_name: '',
  overlay: false,
  stop: '',
  target_legs: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/playback_start');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/playback_start',
  headers: {'content-type': 'application/json'},
  data: {
    audio_url: '',
    client_state: '',
    command_id: '',
    loop: '',
    media_name: '',
    overlay: false,
    stop: '',
    target_legs: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/playback_start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"audio_url":"","client_state":"","command_id":"","loop":"","media_name":"","overlay":false,"stop":"","target_legs":""}'
};

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}}/calls/:call_control_id/actions/playback_start',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "audio_url": "",\n  "client_state": "",\n  "command_id": "",\n  "loop": "",\n  "media_name": "",\n  "overlay": false,\n  "stop": "",\n  "target_legs": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/playback_start")
  .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/calls/:call_control_id/actions/playback_start',
  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({
  audio_url: '',
  client_state: '',
  command_id: '',
  loop: '',
  media_name: '',
  overlay: false,
  stop: '',
  target_legs: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/playback_start',
  headers: {'content-type': 'application/json'},
  body: {
    audio_url: '',
    client_state: '',
    command_id: '',
    loop: '',
    media_name: '',
    overlay: false,
    stop: '',
    target_legs: ''
  },
  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}}/calls/:call_control_id/actions/playback_start');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  audio_url: '',
  client_state: '',
  command_id: '',
  loop: '',
  media_name: '',
  overlay: false,
  stop: '',
  target_legs: ''
});

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}}/calls/:call_control_id/actions/playback_start',
  headers: {'content-type': 'application/json'},
  data: {
    audio_url: '',
    client_state: '',
    command_id: '',
    loop: '',
    media_name: '',
    overlay: false,
    stop: '',
    target_legs: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/playback_start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"audio_url":"","client_state":"","command_id":"","loop":"","media_name":"","overlay":false,"stop":"","target_legs":""}'
};

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 = @{ @"audio_url": @"",
                              @"client_state": @"",
                              @"command_id": @"",
                              @"loop": @"",
                              @"media_name": @"",
                              @"overlay": @NO,
                              @"stop": @"",
                              @"target_legs": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/playback_start"]
                                                       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}}/calls/:call_control_id/actions/playback_start" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/playback_start",
  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([
    'audio_url' => '',
    'client_state' => '',
    'command_id' => '',
    'loop' => '',
    'media_name' => '',
    'overlay' => null,
    'stop' => '',
    'target_legs' => ''
  ]),
  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}}/calls/:call_control_id/actions/playback_start', [
  'body' => '{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "loop": "",
  "media_name": "",
  "overlay": false,
  "stop": "",
  "target_legs": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/playback_start');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'audio_url' => '',
  'client_state' => '',
  'command_id' => '',
  'loop' => '',
  'media_name' => '',
  'overlay' => null,
  'stop' => '',
  'target_legs' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'audio_url' => '',
  'client_state' => '',
  'command_id' => '',
  'loop' => '',
  'media_name' => '',
  'overlay' => null,
  'stop' => '',
  'target_legs' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/playback_start');
$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}}/calls/:call_control_id/actions/playback_start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "loop": "",
  "media_name": "",
  "overlay": false,
  "stop": "",
  "target_legs": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/playback_start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "loop": "",
  "media_name": "",
  "overlay": false,
  "stop": "",
  "target_legs": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/playback_start", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/playback_start"

payload = {
    "audio_url": "",
    "client_state": "",
    "command_id": "",
    "loop": "",
    "media_name": "",
    "overlay": False,
    "stop": "",
    "target_legs": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/playback_start"

payload <- "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\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}}/calls/:call_control_id/actions/playback_start")

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  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\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/calls/:call_control_id/actions/playback_start') do |req|
  req.body = "{\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"loop\": \"\",\n  \"media_name\": \"\",\n  \"overlay\": false,\n  \"stop\": \"\",\n  \"target_legs\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/playback_start";

    let payload = json!({
        "audio_url": "",
        "client_state": "",
        "command_id": "",
        "loop": "",
        "media_name": "",
        "overlay": false,
        "stop": "",
        "target_legs": ""
    });

    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 '{
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "loop": "",
  "media_name": "",
  "overlay": false,
  "stop": "",
  "target_legs": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/playback_start \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "audio_url": "",\n  "client_state": "",\n  "command_id": "",\n  "loop": "",\n  "media_name": "",\n  "overlay": false,\n  "stop": "",\n  "target_legs": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/playback_start

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "loop": "",
  "media_name": "",
  "overlay": false,
  "stop": "",
  "target_legs": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/playback_start")! 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}}/calls/:call_control_id/actions/record_pause");

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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/record_pause" {:content-type :json
                                                                                        :form-params {:client_state ""
                                                                                                      :command_id ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/record_pause"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/record_pause"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/record_pause");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/record_pause"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/record_pause HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "client_state": "",
  "command_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/record_pause")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/record_pause"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/record_pause")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/record_pause")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/record_pause');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/record_pause',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/record_pause';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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}}/calls/:call_control_id/actions/record_pause',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/record_pause")
  .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/calls/:call_control_id/actions/record_pause',
  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({client_state: '', command_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/record_pause',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: ''},
  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}}/calls/:call_control_id/actions/record_pause');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: ''
});

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}}/calls/:call_control_id/actions/record_pause',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/record_pause';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/record_pause"]
                                                       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}}/calls/:call_control_id/actions/record_pause" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/record_pause",
  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([
    'client_state' => '',
    'command_id' => ''
  ]),
  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}}/calls/:call_control_id/actions/record_pause', [
  'body' => '{
  "client_state": "",
  "command_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/record_pause');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/record_pause');
$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}}/calls/:call_control_id/actions/record_pause' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/record_pause' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/record_pause", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/record_pause"

payload = {
    "client_state": "",
    "command_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/record_pause"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/record_pause")

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  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/record_pause') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/record_pause";

    let payload = json!({
        "client_state": "",
        "command_id": ""
    });

    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 '{
  "client_state": "",
  "command_id": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/record_pause \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/record_pause

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/record_pause")! 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}}/calls/:call_control_id/actions/record_resume");

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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/record_resume" {:content-type :json
                                                                                         :form-params {:client_state ""
                                                                                                       :command_id ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/record_resume"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/record_resume"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/record_resume");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/record_resume"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/record_resume HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "client_state": "",
  "command_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/record_resume")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/record_resume"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/record_resume")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/record_resume")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/record_resume');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/record_resume',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/record_resume';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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}}/calls/:call_control_id/actions/record_resume',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/record_resume")
  .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/calls/:call_control_id/actions/record_resume',
  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({client_state: '', command_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/record_resume',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: ''},
  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}}/calls/:call_control_id/actions/record_resume');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: ''
});

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}}/calls/:call_control_id/actions/record_resume',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/record_resume';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/record_resume"]
                                                       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}}/calls/:call_control_id/actions/record_resume" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/record_resume",
  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([
    'client_state' => '',
    'command_id' => ''
  ]),
  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}}/calls/:call_control_id/actions/record_resume', [
  'body' => '{
  "client_state": "",
  "command_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/record_resume');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/record_resume');
$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}}/calls/:call_control_id/actions/record_resume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/record_resume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/record_resume", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/record_resume"

payload = {
    "client_state": "",
    "command_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/record_resume"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/record_resume")

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  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/record_resume') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/record_resume";

    let payload = json!({
        "client_state": "",
        "command_id": ""
    });

    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 '{
  "client_state": "",
  "command_id": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/record_resume \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/record_resume

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/record_resume")! 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}}/calls/:call_control_id/actions/record_start");

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  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/record_start" {:content-type :json
                                                                                        :form-params {:channels ""
                                                                                                      :client_state ""
                                                                                                      :command_id ""
                                                                                                      :format ""
                                                                                                      :max_length 0
                                                                                                      :play_beep false}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/record_start"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": 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}}/calls/:call_control_id/actions/record_start"),
    Content = new StringContent("{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": 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}}/calls/:call_control_id/actions/record_start");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/record_start"

	payload := strings.NewReader("{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": 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/calls/:call_control_id/actions/record_start HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 119

{
  "channels": "",
  "client_state": "",
  "command_id": "",
  "format": "",
  "max_length": 0,
  "play_beep": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/record_start")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/record_start"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": 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  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/record_start")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/record_start")
  .header("content-type", "application/json")
  .body("{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": false\n}")
  .asString();

const data = JSON.stringify({
  channels: '',
  client_state: '',
  command_id: '',
  format: '',
  max_length: 0,
  play_beep: 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}}/calls/:call_control_id/actions/record_start');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/record_start',
  headers: {'content-type': 'application/json'},
  data: {
    channels: '',
    client_state: '',
    command_id: '',
    format: '',
    max_length: 0,
    play_beep: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/record_start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channels":"","client_state":"","command_id":"","format":"","max_length":0,"play_beep":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}}/calls/:call_control_id/actions/record_start',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "channels": "",\n  "client_state": "",\n  "command_id": "",\n  "format": "",\n  "max_length": 0,\n  "play_beep": 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  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/record_start")
  .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/calls/:call_control_id/actions/record_start',
  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({
  channels: '',
  client_state: '',
  command_id: '',
  format: '',
  max_length: 0,
  play_beep: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/record_start',
  headers: {'content-type': 'application/json'},
  body: {
    channels: '',
    client_state: '',
    command_id: '',
    format: '',
    max_length: 0,
    play_beep: 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}}/calls/:call_control_id/actions/record_start');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  channels: '',
  client_state: '',
  command_id: '',
  format: '',
  max_length: 0,
  play_beep: 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}}/calls/:call_control_id/actions/record_start',
  headers: {'content-type': 'application/json'},
  data: {
    channels: '',
    client_state: '',
    command_id: '',
    format: '',
    max_length: 0,
    play_beep: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/record_start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channels":"","client_state":"","command_id":"","format":"","max_length":0,"play_beep":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 = @{ @"channels": @"",
                              @"client_state": @"",
                              @"command_id": @"",
                              @"format": @"",
                              @"max_length": @0,
                              @"play_beep": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/record_start"]
                                                       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}}/calls/:call_control_id/actions/record_start" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/record_start",
  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([
    'channels' => '',
    'client_state' => '',
    'command_id' => '',
    'format' => '',
    'max_length' => 0,
    'play_beep' => 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}}/calls/:call_control_id/actions/record_start', [
  'body' => '{
  "channels": "",
  "client_state": "",
  "command_id": "",
  "format": "",
  "max_length": 0,
  "play_beep": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/record_start');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'channels' => '',
  'client_state' => '',
  'command_id' => '',
  'format' => '',
  'max_length' => 0,
  'play_beep' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'channels' => '',
  'client_state' => '',
  'command_id' => '',
  'format' => '',
  'max_length' => 0,
  'play_beep' => null
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/record_start');
$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}}/calls/:call_control_id/actions/record_start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channels": "",
  "client_state": "",
  "command_id": "",
  "format": "",
  "max_length": 0,
  "play_beep": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/record_start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channels": "",
  "client_state": "",
  "command_id": "",
  "format": "",
  "max_length": 0,
  "play_beep": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/record_start", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/record_start"

payload = {
    "channels": "",
    "client_state": "",
    "command_id": "",
    "format": "",
    "max_length": 0,
    "play_beep": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/record_start"

payload <- "{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": 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}}/calls/:call_control_id/actions/record_start")

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  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": 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/calls/:call_control_id/actions/record_start') do |req|
  req.body = "{\n  \"channels\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"format\": \"\",\n  \"max_length\": 0,\n  \"play_beep\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/record_start";

    let payload = json!({
        "channels": "",
        "client_state": "",
        "command_id": "",
        "format": "",
        "max_length": 0,
        "play_beep": 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 '{
  "channels": "",
  "client_state": "",
  "command_id": "",
  "format": "",
  "max_length": 0,
  "play_beep": false
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/record_start \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "channels": "",\n  "client_state": "",\n  "command_id": "",\n  "format": "",\n  "max_length": 0,\n  "play_beep": false\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/record_start

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "channels": "",
  "client_state": "",
  "command_id": "",
  "format": "",
  "max_length": 0,
  "play_beep": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/record_start")! 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}}/calls/:call_control_id/actions/record_stop");

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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/record_stop" {:content-type :json
                                                                                       :form-params {:client_state ""
                                                                                                     :command_id ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/record_stop"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/record_stop"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/record_stop");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/record_stop"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/record_stop HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "client_state": "",
  "command_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/record_stop")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/record_stop"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/record_stop")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/record_stop")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/record_stop');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/record_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/record_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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}}/calls/:call_control_id/actions/record_stop',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/record_stop")
  .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/calls/:call_control_id/actions/record_stop',
  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({client_state: '', command_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/record_stop',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: ''},
  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}}/calls/:call_control_id/actions/record_stop');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: ''
});

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}}/calls/:call_control_id/actions/record_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/record_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/record_stop"]
                                                       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}}/calls/:call_control_id/actions/record_stop" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/record_stop",
  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([
    'client_state' => '',
    'command_id' => ''
  ]),
  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}}/calls/:call_control_id/actions/record_stop', [
  'body' => '{
  "client_state": "",
  "command_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/record_stop');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/record_stop');
$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}}/calls/:call_control_id/actions/record_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/record_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/record_stop", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/record_stop"

payload = {
    "client_state": "",
    "command_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/record_stop"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/record_stop")

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  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/record_stop') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/record_stop";

    let payload = json!({
        "client_state": "",
        "command_id": ""
    });

    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 '{
  "client_state": "",
  "command_id": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/record_stop \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/record_stop

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/record_stop")! 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}}/calls/:call_control_id/actions/reject");

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  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/reject" {:content-type :json
                                                                                  :form-params {:cause ""
                                                                                                :client_state ""
                                                                                                :command_id ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/reject"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/reject"),
    Content = new StringContent("{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/reject");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/reject"

	payload := strings.NewReader("{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/reject HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "cause": "",
  "client_state": "",
  "command_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/reject")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/reject"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/reject")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/reject")
  .header("content-type", "application/json")
  .body("{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cause: '',
  client_state: '',
  command_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/reject');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/reject',
  headers: {'content-type': 'application/json'},
  data: {cause: '', client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/reject';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"cause":"","client_state":"","command_id":""}'
};

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}}/calls/:call_control_id/actions/reject',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cause": "",\n  "client_state": "",\n  "command_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/reject")
  .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/calls/:call_control_id/actions/reject',
  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({cause: '', client_state: '', command_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/reject',
  headers: {'content-type': 'application/json'},
  body: {cause: '', client_state: '', command_id: ''},
  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}}/calls/:call_control_id/actions/reject');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cause: '',
  client_state: '',
  command_id: ''
});

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}}/calls/:call_control_id/actions/reject',
  headers: {'content-type': 'application/json'},
  data: {cause: '', client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/reject';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"cause":"","client_state":"","command_id":""}'
};

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 = @{ @"cause": @"",
                              @"client_state": @"",
                              @"command_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/reject"]
                                                       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}}/calls/:call_control_id/actions/reject" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/reject",
  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([
    'cause' => '',
    'client_state' => '',
    'command_id' => ''
  ]),
  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}}/calls/:call_control_id/actions/reject', [
  'body' => '{
  "cause": "",
  "client_state": "",
  "command_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/reject');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cause' => '',
  'client_state' => '',
  'command_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cause' => '',
  'client_state' => '',
  'command_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/reject');
$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}}/calls/:call_control_id/actions/reject' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cause": "",
  "client_state": "",
  "command_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/reject' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cause": "",
  "client_state": "",
  "command_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/reject", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/reject"

payload = {
    "cause": "",
    "client_state": "",
    "command_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/reject"

payload <- "{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/reject")

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  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/reject') do |req|
  req.body = "{\n  \"cause\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/reject";

    let payload = json!({
        "cause": "",
        "client_state": "",
        "command_id": ""
    });

    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 '{
  "cause": "",
  "client_state": "",
  "command_id": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/reject \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "cause": "",\n  "client_state": "",\n  "command_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/reject

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cause": "",
  "client_state": "",
  "command_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/reject")! 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}}/calls/:call_control_id/actions/leave_queue");

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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/leave_queue" {:content-type :json
                                                                                       :form-params {:client_state ""
                                                                                                     :command_id ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/leave_queue"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/leave_queue"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/leave_queue");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/leave_queue"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/leave_queue HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "client_state": "",
  "command_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/leave_queue")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/leave_queue"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/leave_queue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/leave_queue")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/leave_queue');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/leave_queue',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/leave_queue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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}}/calls/:call_control_id/actions/leave_queue',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/leave_queue")
  .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/calls/:call_control_id/actions/leave_queue',
  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({client_state: '', command_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/leave_queue',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: ''},
  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}}/calls/:call_control_id/actions/leave_queue');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: ''
});

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}}/calls/:call_control_id/actions/leave_queue',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/leave_queue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/leave_queue"]
                                                       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}}/calls/:call_control_id/actions/leave_queue" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/leave_queue",
  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([
    'client_state' => '',
    'command_id' => ''
  ]),
  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}}/calls/:call_control_id/actions/leave_queue', [
  'body' => '{
  "client_state": "",
  "command_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/leave_queue');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/leave_queue');
$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}}/calls/:call_control_id/actions/leave_queue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/leave_queue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/leave_queue", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/leave_queue"

payload = {
    "client_state": "",
    "command_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/leave_queue"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/leave_queue")

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  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/leave_queue') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/leave_queue";

    let payload = json!({
        "client_state": "",
        "command_id": ""
    });

    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 '{
  "client_state": "",
  "command_id": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/leave_queue \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/leave_queue

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/leave_queue")! 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}}/calls/:call_control_id/actions/refer");

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/refer" {:content-type :json
                                                                                 :form-params {:client_state ""
                                                                                               :command_id ""
                                                                                               :custom_headers [{:name ""
                                                                                                                 :value ""}]
                                                                                               :sip_address ""
                                                                                               :sip_auth_password ""
                                                                                               :sip_auth_username ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/refer"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\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}}/calls/:call_control_id/actions/refer"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\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}}/calls/:call_control_id/actions/refer");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/refer"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\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/calls/:call_control_id/actions/refer HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 194

{
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "sip_address": "",
  "sip_auth_password": "",
  "sip_auth_username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/refer")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/refer"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/refer")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/refer")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: '',
  custom_headers: [
    {
      name: '',
      value: ''
    }
  ],
  sip_address: '',
  sip_auth_password: '',
  sip_auth_username: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/refer');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/refer',
  headers: {'content-type': 'application/json'},
  data: {
    client_state: '',
    command_id: '',
    custom_headers: [{name: '', value: ''}],
    sip_address: '',
    sip_auth_password: '',
    sip_auth_username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/refer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","custom_headers":[{"name":"","value":""}],"sip_address":"","sip_auth_password":"","sip_auth_username":""}'
};

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}}/calls/:call_control_id/actions/refer',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": "",\n  "custom_headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "sip_address": "",\n  "sip_auth_password": "",\n  "sip_auth_username": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/refer")
  .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/calls/:call_control_id/actions/refer',
  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({
  client_state: '',
  command_id: '',
  custom_headers: [{name: '', value: ''}],
  sip_address: '',
  sip_auth_password: '',
  sip_auth_username: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/refer',
  headers: {'content-type': 'application/json'},
  body: {
    client_state: '',
    command_id: '',
    custom_headers: [{name: '', value: ''}],
    sip_address: '',
    sip_auth_password: '',
    sip_auth_username: ''
  },
  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}}/calls/:call_control_id/actions/refer');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: '',
  custom_headers: [
    {
      name: '',
      value: ''
    }
  ],
  sip_address: '',
  sip_auth_password: '',
  sip_auth_username: ''
});

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}}/calls/:call_control_id/actions/refer',
  headers: {'content-type': 'application/json'},
  data: {
    client_state: '',
    command_id: '',
    custom_headers: [{name: '', value: ''}],
    sip_address: '',
    sip_auth_password: '',
    sip_auth_username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/refer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","custom_headers":[{"name":"","value":""}],"sip_address":"","sip_auth_password":"","sip_auth_username":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"",
                              @"custom_headers": @[ @{ @"name": @"", @"value": @"" } ],
                              @"sip_address": @"",
                              @"sip_auth_password": @"",
                              @"sip_auth_username": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/refer"]
                                                       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}}/calls/:call_control_id/actions/refer" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/refer",
  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([
    'client_state' => '',
    'command_id' => '',
    'custom_headers' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'sip_address' => '',
    'sip_auth_password' => '',
    'sip_auth_username' => ''
  ]),
  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}}/calls/:call_control_id/actions/refer', [
  'body' => '{
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "sip_address": "",
  "sip_auth_password": "",
  "sip_auth_username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/refer');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => '',
  'custom_headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'sip_address' => '',
  'sip_auth_password' => '',
  'sip_auth_username' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => '',
  'custom_headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'sip_address' => '',
  'sip_auth_password' => '',
  'sip_auth_username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/refer');
$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}}/calls/:call_control_id/actions/refer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "sip_address": "",
  "sip_auth_password": "",
  "sip_auth_username": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/refer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "sip_address": "",
  "sip_auth_password": "",
  "sip_auth_username": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/refer", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/refer"

payload = {
    "client_state": "",
    "command_id": "",
    "custom_headers": [
        {
            "name": "",
            "value": ""
        }
    ],
    "sip_address": "",
    "sip_auth_password": "",
    "sip_auth_username": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/refer"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\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}}/calls/:call_control_id/actions/refer")

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\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/calls/:call_control_id/actions/refer') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"sip_address\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/refer";

    let payload = json!({
        "client_state": "",
        "command_id": "",
        "custom_headers": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "sip_address": "",
        "sip_auth_password": "",
        "sip_auth_username": ""
    });

    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 '{
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "sip_address": "",
  "sip_auth_password": "",
  "sip_auth_username": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/refer \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": "",\n  "custom_headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "sip_address": "",\n  "sip_auth_password": "",\n  "sip_auth_username": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/refer

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "sip_address": "",
  "sip_auth_password": "",
  "sip_auth_username": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/refer")! 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}}/calls/:call_control_id/actions/send_dtmf");

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/send_dtmf" {:content-type :json
                                                                                     :form-params {:client_state ""
                                                                                                   :command_id ""
                                                                                                   :digits ""
                                                                                                   :duration_millis 0}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/send_dtmf"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\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}}/calls/:call_control_id/actions/send_dtmf"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/calls/:call_control_id/actions/send_dtmf");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/send_dtmf"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\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/calls/:call_control_id/actions/send_dtmf HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "client_state": "",
  "command_id": "",
  "digits": "",
  "duration_millis": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/send_dtmf")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/send_dtmf"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/send_dtmf")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/send_dtmf")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: '',
  digits: '',
  duration_millis: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/send_dtmf');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/send_dtmf',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: '', digits: '', duration_millis: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/send_dtmf';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","digits":"","duration_millis":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/calls/:call_control_id/actions/send_dtmf',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": "",\n  "digits": "",\n  "duration_millis": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/send_dtmf")
  .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/calls/:call_control_id/actions/send_dtmf',
  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({client_state: '', command_id: '', digits: '', duration_millis: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/send_dtmf',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: '', digits: '', duration_millis: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/calls/:call_control_id/actions/send_dtmf');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: '',
  digits: '',
  duration_millis: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/send_dtmf',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: '', digits: '', duration_millis: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/send_dtmf';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","digits":"","duration_millis":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"client_state": @"",
                              @"command_id": @"",
                              @"digits": @"",
                              @"duration_millis": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/send_dtmf"]
                                                       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}}/calls/:call_control_id/actions/send_dtmf" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/send_dtmf",
  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([
    'client_state' => '',
    'command_id' => '',
    'digits' => '',
    'duration_millis' => 0
  ]),
  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}}/calls/:call_control_id/actions/send_dtmf', [
  'body' => '{
  "client_state": "",
  "command_id": "",
  "digits": "",
  "duration_millis": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/send_dtmf');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => '',
  'digits' => '',
  'duration_millis' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => '',
  'digits' => '',
  'duration_millis' => 0
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/send_dtmf');
$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}}/calls/:call_control_id/actions/send_dtmf' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "digits": "",
  "duration_millis": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/send_dtmf' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "digits": "",
  "duration_millis": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/send_dtmf", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/send_dtmf"

payload = {
    "client_state": "",
    "command_id": "",
    "digits": "",
    "duration_millis": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/send_dtmf"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\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}}/calls/:call_control_id/actions/send_dtmf")

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\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/calls/:call_control_id/actions/send_dtmf') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"digits\": \"\",\n  \"duration_millis\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/send_dtmf";

    let payload = json!({
        "client_state": "",
        "command_id": "",
        "digits": "",
        "duration_millis": 0
    });

    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 '{
  "client_state": "",
  "command_id": "",
  "digits": "",
  "duration_millis": 0
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/send_dtmf \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": "",\n  "digits": "",\n  "duration_millis": 0\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/send_dtmf

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": "",
  "digits": "",
  "duration_millis": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/send_dtmf")! 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}}/calls/:call_control_id/actions/speak");

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/speak" {:content-type :json
                                                                                 :form-params {:client_state ""
                                                                                               :command_id ""
                                                                                               :language ""
                                                                                               :payload ""
                                                                                               :payload_type ""
                                                                                               :service_level ""
                                                                                               :stop ""
                                                                                               :voice ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/speak"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\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}}/calls/:call_control_id/actions/speak"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\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}}/calls/:call_control_id/actions/speak");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/speak"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\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/calls/:call_control_id/actions/speak HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 153

{
  "client_state": "",
  "command_id": "",
  "language": "",
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "stop": "",
  "voice": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/speak")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/speak"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/speak")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/speak")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: '',
  language: '',
  payload: '',
  payload_type: '',
  service_level: '',
  stop: '',
  voice: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/speak');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/speak',
  headers: {'content-type': 'application/json'},
  data: {
    client_state: '',
    command_id: '',
    language: '',
    payload: '',
    payload_type: '',
    service_level: '',
    stop: '',
    voice: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/speak';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","language":"","payload":"","payload_type":"","service_level":"","stop":"","voice":""}'
};

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}}/calls/:call_control_id/actions/speak',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": "",\n  "language": "",\n  "payload": "",\n  "payload_type": "",\n  "service_level": "",\n  "stop": "",\n  "voice": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/speak")
  .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/calls/:call_control_id/actions/speak',
  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({
  client_state: '',
  command_id: '',
  language: '',
  payload: '',
  payload_type: '',
  service_level: '',
  stop: '',
  voice: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/speak',
  headers: {'content-type': 'application/json'},
  body: {
    client_state: '',
    command_id: '',
    language: '',
    payload: '',
    payload_type: '',
    service_level: '',
    stop: '',
    voice: ''
  },
  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}}/calls/:call_control_id/actions/speak');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: '',
  language: '',
  payload: '',
  payload_type: '',
  service_level: '',
  stop: '',
  voice: ''
});

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}}/calls/:call_control_id/actions/speak',
  headers: {'content-type': 'application/json'},
  data: {
    client_state: '',
    command_id: '',
    language: '',
    payload: '',
    payload_type: '',
    service_level: '',
    stop: '',
    voice: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/speak';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","language":"","payload":"","payload_type":"","service_level":"","stop":"","voice":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"",
                              @"language": @"",
                              @"payload": @"",
                              @"payload_type": @"",
                              @"service_level": @"",
                              @"stop": @"",
                              @"voice": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/speak"]
                                                       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}}/calls/:call_control_id/actions/speak" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/speak",
  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([
    'client_state' => '',
    'command_id' => '',
    'language' => '',
    'payload' => '',
    'payload_type' => '',
    'service_level' => '',
    'stop' => '',
    'voice' => ''
  ]),
  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}}/calls/:call_control_id/actions/speak', [
  'body' => '{
  "client_state": "",
  "command_id": "",
  "language": "",
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "stop": "",
  "voice": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/speak');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => '',
  'language' => '',
  'payload' => '',
  'payload_type' => '',
  'service_level' => '',
  'stop' => '',
  'voice' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => '',
  'language' => '',
  'payload' => '',
  'payload_type' => '',
  'service_level' => '',
  'stop' => '',
  'voice' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/speak');
$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}}/calls/:call_control_id/actions/speak' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "language": "",
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "stop": "",
  "voice": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/speak' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "language": "",
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "stop": "",
  "voice": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/speak", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/speak"

payload = {
    "client_state": "",
    "command_id": "",
    "language": "",
    "payload": "",
    "payload_type": "",
    "service_level": "",
    "stop": "",
    "voice": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/speak"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\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}}/calls/:call_control_id/actions/speak")

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\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/calls/:call_control_id/actions/speak') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\",\n  \"payload\": \"\",\n  \"payload_type\": \"\",\n  \"service_level\": \"\",\n  \"stop\": \"\",\n  \"voice\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/speak";

    let payload = json!({
        "client_state": "",
        "command_id": "",
        "language": "",
        "payload": "",
        "payload_type": "",
        "service_level": "",
        "stop": "",
        "voice": ""
    });

    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 '{
  "client_state": "",
  "command_id": "",
  "language": "",
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "stop": "",
  "voice": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/speak \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": "",\n  "language": "",\n  "payload": "",\n  "payload_type": "",\n  "service_level": "",\n  "stop": "",\n  "voice": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/speak

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": "",
  "language": "",
  "payload": "",
  "payload_type": "",
  "service_level": "",
  "stop": "",
  "voice": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/speak")! 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}}/calls/:call_control_id/actions/playback_stop");

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/playback_stop" {:content-type :json
                                                                                         :form-params {:client_state ""
                                                                                                       :command_id ""
                                                                                                       :stop ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/playback_stop"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\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}}/calls/:call_control_id/actions/playback_stop"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\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}}/calls/:call_control_id/actions/playback_stop");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/playback_stop"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\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/calls/:call_control_id/actions/playback_stop HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "client_state": "",
  "command_id": "",
  "stop": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/playback_stop")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/playback_stop"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/playback_stop")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/playback_stop")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: '',
  stop: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/playback_stop');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/playback_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: '', stop: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/playback_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","stop":""}'
};

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}}/calls/:call_control_id/actions/playback_stop',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": "",\n  "stop": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/playback_stop")
  .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/calls/:call_control_id/actions/playback_stop',
  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({client_state: '', command_id: '', stop: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/playback_stop',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: '', stop: ''},
  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}}/calls/:call_control_id/actions/playback_stop');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: '',
  stop: ''
});

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}}/calls/:call_control_id/actions/playback_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: '', stop: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/playback_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","stop":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"",
                              @"stop": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/playback_stop"]
                                                       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}}/calls/:call_control_id/actions/playback_stop" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/playback_stop",
  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([
    'client_state' => '',
    'command_id' => '',
    'stop' => ''
  ]),
  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}}/calls/:call_control_id/actions/playback_stop', [
  'body' => '{
  "client_state": "",
  "command_id": "",
  "stop": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/playback_stop');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => '',
  'stop' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => '',
  'stop' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/playback_stop');
$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}}/calls/:call_control_id/actions/playback_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "stop": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/playback_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "stop": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/playback_stop", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/playback_stop"

payload = {
    "client_state": "",
    "command_id": "",
    "stop": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/playback_stop"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\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}}/calls/:call_control_id/actions/playback_stop")

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\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/calls/:call_control_id/actions/playback_stop') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"stop\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/playback_stop";

    let payload = json!({
        "client_state": "",
        "command_id": "",
        "stop": ""
    });

    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 '{
  "client_state": "",
  "command_id": "",
  "stop": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/playback_stop \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": "",\n  "stop": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/playback_stop

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": "",
  "stop": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/playback_stop")! 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}}/calls/:call_control_id/actions/transcription_start");

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/transcription_start" {:content-type :json
                                                                                               :form-params {:client_state ""
                                                                                                             :command_id ""
                                                                                                             :language ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/transcription_start"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\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}}/calls/:call_control_id/actions/transcription_start"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\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}}/calls/:call_control_id/actions/transcription_start");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/transcription_start"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\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/calls/:call_control_id/actions/transcription_start HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 62

{
  "client_state": "",
  "command_id": "",
  "language": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/transcription_start")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/transcription_start"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/transcription_start")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/transcription_start")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: '',
  language: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/transcription_start');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/transcription_start',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: '', language: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/transcription_start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","language":""}'
};

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}}/calls/:call_control_id/actions/transcription_start',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": "",\n  "language": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/transcription_start")
  .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/calls/:call_control_id/actions/transcription_start',
  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({client_state: '', command_id: '', language: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/transcription_start',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: '', language: ''},
  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}}/calls/:call_control_id/actions/transcription_start');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: '',
  language: ''
});

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}}/calls/:call_control_id/actions/transcription_start',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: '', language: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/transcription_start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":"","language":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"",
                              @"language": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/transcription_start"]
                                                       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}}/calls/:call_control_id/actions/transcription_start" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/transcription_start",
  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([
    'client_state' => '',
    'command_id' => '',
    'language' => ''
  ]),
  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}}/calls/:call_control_id/actions/transcription_start', [
  'body' => '{
  "client_state": "",
  "command_id": "",
  "language": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/transcription_start');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => '',
  'language' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => '',
  'language' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/transcription_start');
$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}}/calls/:call_control_id/actions/transcription_start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "language": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/transcription_start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": "",
  "language": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/transcription_start", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/transcription_start"

payload = {
    "client_state": "",
    "command_id": "",
    "language": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/transcription_start"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\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}}/calls/:call_control_id/actions/transcription_start")

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  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\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/calls/:call_control_id/actions/transcription_start') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"language\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/transcription_start";

    let payload = json!({
        "client_state": "",
        "command_id": "",
        "language": ""
    });

    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 '{
  "client_state": "",
  "command_id": "",
  "language": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/transcription_start \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": "",\n  "language": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/transcription_start

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": "",
  "language": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/transcription_start")! 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}}/calls/:call_control_id/actions/transcription_stop");

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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/transcription_stop" {:content-type :json
                                                                                              :form-params {:client_state ""
                                                                                                            :command_id ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/transcription_stop"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/transcription_stop"),
    Content = new StringContent("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/transcription_stop");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/transcription_stop"

	payload := strings.NewReader("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/transcription_stop HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "client_state": "",
  "command_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/transcription_stop")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/transcription_stop"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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  \"client_state\": \"\",\n  \"command_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/transcription_stop")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/transcription_stop")
  .header("content-type", "application/json")
  .body("{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  client_state: '',
  command_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/transcription_stop');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/transcription_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/transcription_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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}}/calls/:call_control_id/actions/transcription_stop',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "client_state": "",\n  "command_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/transcription_stop")
  .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/calls/:call_control_id/actions/transcription_stop',
  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({client_state: '', command_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/transcription_stop',
  headers: {'content-type': 'application/json'},
  body: {client_state: '', command_id: ''},
  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}}/calls/:call_control_id/actions/transcription_stop');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  client_state: '',
  command_id: ''
});

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}}/calls/:call_control_id/actions/transcription_stop',
  headers: {'content-type': 'application/json'},
  data: {client_state: '', command_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/transcription_stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"client_state":"","command_id":""}'
};

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 = @{ @"client_state": @"",
                              @"command_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/transcription_stop"]
                                                       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}}/calls/:call_control_id/actions/transcription_stop" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/transcription_stop",
  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([
    'client_state' => '',
    'command_id' => ''
  ]),
  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}}/calls/:call_control_id/actions/transcription_stop', [
  'body' => '{
  "client_state": "",
  "command_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/transcription_stop');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'client_state' => '',
  'command_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'client_state' => '',
  'command_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/transcription_stop');
$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}}/calls/:call_control_id/actions/transcription_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/transcription_stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "client_state": "",
  "command_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/transcription_stop", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/transcription_stop"

payload = {
    "client_state": "",
    "command_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/transcription_stop"

payload <- "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\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}}/calls/:call_control_id/actions/transcription_stop")

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  \"client_state\": \"\",\n  \"command_id\": \"\"\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/calls/:call_control_id/actions/transcription_stop') do |req|
  req.body = "{\n  \"client_state\": \"\",\n  \"command_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/transcription_stop";

    let payload = json!({
        "client_state": "",
        "command_id": ""
    });

    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 '{
  "client_state": "",
  "command_id": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/transcription_stop \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "client_state": "",\n  "command_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/transcription_stop

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_state": "",
  "command_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/transcription_stop")! 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}}/calls/:call_control_id/actions/transfer");

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  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calls/:call_control_id/actions/transfer" {:content-type :json
                                                                                    :form-params {:answering_machine_detection ""
                                                                                                  :answering_machine_detection_config {:after_greeting_silence_millis 0
                                                                                                                                       :between_words_silence_millis 0
                                                                                                                                       :greeting_duration_millis 0
                                                                                                                                       :greeting_silence_duration_millis 0
                                                                                                                                       :greeting_total_analysis_time_millis 0
                                                                                                                                       :initial_silence_millis 0
                                                                                                                                       :maximum_number_of_words 0
                                                                                                                                       :maximum_word_length_millis 0
                                                                                                                                       :silence_threshold 0
                                                                                                                                       :total_analysis_time_millis 0}
                                                                                                  :audio_url ""
                                                                                                  :client_state ""
                                                                                                  :command_id ""
                                                                                                  :custom_headers [{:name ""
                                                                                                                    :value ""}]
                                                                                                  :from ""
                                                                                                  :from_display_name ""
                                                                                                  :media_name ""
                                                                                                  :sip_auth_password ""
                                                                                                  :sip_auth_username ""
                                                                                                  :target_leg_client_state ""
                                                                                                  :time_limit_secs 0
                                                                                                  :timeout_secs 0
                                                                                                  :to ""
                                                                                                  :webhook_url ""
                                                                                                  :webhook_url_method ""}})

require "http/client"

url = "{{baseUrl}}/calls/:call_control_id/actions/transfer"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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}}/calls/:call_control_id/actions/transfer"),
    Content = new StringContent("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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}}/calls/:call_control_id/actions/transfer");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/calls/:call_control_id/actions/transfer"

	payload := strings.NewReader("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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/calls/:call_control_id/actions/transfer HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 847

{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "target_leg_client_state": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/calls/:call_control_id/actions/transfer")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calls/:call_control_id/actions/transfer"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/transfer")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/calls/:call_control_id/actions/transfer")
  .header("content-type", "application/json")
  .body("{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  answering_machine_detection: '',
  answering_machine_detection_config: {
    after_greeting_silence_millis: 0,
    between_words_silence_millis: 0,
    greeting_duration_millis: 0,
    greeting_silence_duration_millis: 0,
    greeting_total_analysis_time_millis: 0,
    initial_silence_millis: 0,
    maximum_number_of_words: 0,
    maximum_word_length_millis: 0,
    silence_threshold: 0,
    total_analysis_time_millis: 0
  },
  audio_url: '',
  client_state: '',
  command_id: '',
  custom_headers: [
    {
      name: '',
      value: ''
    }
  ],
  from: '',
  from_display_name: '',
  media_name: '',
  sip_auth_password: '',
  sip_auth_username: '',
  target_leg_client_state: '',
  time_limit_secs: 0,
  timeout_secs: 0,
  to: '',
  webhook_url: '',
  webhook_url_method: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/calls/:call_control_id/actions/transfer');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/transfer',
  headers: {'content-type': 'application/json'},
  data: {
    answering_machine_detection: '',
    answering_machine_detection_config: {
      after_greeting_silence_millis: 0,
      between_words_silence_millis: 0,
      greeting_duration_millis: 0,
      greeting_silence_duration_millis: 0,
      greeting_total_analysis_time_millis: 0,
      initial_silence_millis: 0,
      maximum_number_of_words: 0,
      maximum_word_length_millis: 0,
      silence_threshold: 0,
      total_analysis_time_millis: 0
    },
    audio_url: '',
    client_state: '',
    command_id: '',
    custom_headers: [{name: '', value: ''}],
    from: '',
    from_display_name: '',
    media_name: '',
    sip_auth_password: '',
    sip_auth_username: '',
    target_leg_client_state: '',
    time_limit_secs: 0,
    timeout_secs: 0,
    to: '',
    webhook_url: '',
    webhook_url_method: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/calls/:call_control_id/actions/transfer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"answering_machine_detection":"","answering_machine_detection_config":{"after_greeting_silence_millis":0,"between_words_silence_millis":0,"greeting_duration_millis":0,"greeting_silence_duration_millis":0,"greeting_total_analysis_time_millis":0,"initial_silence_millis":0,"maximum_number_of_words":0,"maximum_word_length_millis":0,"silence_threshold":0,"total_analysis_time_millis":0},"audio_url":"","client_state":"","command_id":"","custom_headers":[{"name":"","value":""}],"from":"","from_display_name":"","media_name":"","sip_auth_password":"","sip_auth_username":"","target_leg_client_state":"","time_limit_secs":0,"timeout_secs":0,"to":"","webhook_url":"","webhook_url_method":""}'
};

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}}/calls/:call_control_id/actions/transfer',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "answering_machine_detection": "",\n  "answering_machine_detection_config": {\n    "after_greeting_silence_millis": 0,\n    "between_words_silence_millis": 0,\n    "greeting_duration_millis": 0,\n    "greeting_silence_duration_millis": 0,\n    "greeting_total_analysis_time_millis": 0,\n    "initial_silence_millis": 0,\n    "maximum_number_of_words": 0,\n    "maximum_word_length_millis": 0,\n    "silence_threshold": 0,\n    "total_analysis_time_millis": 0\n  },\n  "audio_url": "",\n  "client_state": "",\n  "command_id": "",\n  "custom_headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "from": "",\n  "from_display_name": "",\n  "media_name": "",\n  "sip_auth_password": "",\n  "sip_auth_username": "",\n  "target_leg_client_state": "",\n  "time_limit_secs": 0,\n  "timeout_secs": 0,\n  "to": "",\n  "webhook_url": "",\n  "webhook_url_method": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calls/:call_control_id/actions/transfer")
  .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/calls/:call_control_id/actions/transfer',
  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({
  answering_machine_detection: '',
  answering_machine_detection_config: {
    after_greeting_silence_millis: 0,
    between_words_silence_millis: 0,
    greeting_duration_millis: 0,
    greeting_silence_duration_millis: 0,
    greeting_total_analysis_time_millis: 0,
    initial_silence_millis: 0,
    maximum_number_of_words: 0,
    maximum_word_length_millis: 0,
    silence_threshold: 0,
    total_analysis_time_millis: 0
  },
  audio_url: '',
  client_state: '',
  command_id: '',
  custom_headers: [{name: '', value: ''}],
  from: '',
  from_display_name: '',
  media_name: '',
  sip_auth_password: '',
  sip_auth_username: '',
  target_leg_client_state: '',
  time_limit_secs: 0,
  timeout_secs: 0,
  to: '',
  webhook_url: '',
  webhook_url_method: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calls/:call_control_id/actions/transfer',
  headers: {'content-type': 'application/json'},
  body: {
    answering_machine_detection: '',
    answering_machine_detection_config: {
      after_greeting_silence_millis: 0,
      between_words_silence_millis: 0,
      greeting_duration_millis: 0,
      greeting_silence_duration_millis: 0,
      greeting_total_analysis_time_millis: 0,
      initial_silence_millis: 0,
      maximum_number_of_words: 0,
      maximum_word_length_millis: 0,
      silence_threshold: 0,
      total_analysis_time_millis: 0
    },
    audio_url: '',
    client_state: '',
    command_id: '',
    custom_headers: [{name: '', value: ''}],
    from: '',
    from_display_name: '',
    media_name: '',
    sip_auth_password: '',
    sip_auth_username: '',
    target_leg_client_state: '',
    time_limit_secs: 0,
    timeout_secs: 0,
    to: '',
    webhook_url: '',
    webhook_url_method: ''
  },
  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}}/calls/:call_control_id/actions/transfer');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  answering_machine_detection: '',
  answering_machine_detection_config: {
    after_greeting_silence_millis: 0,
    between_words_silence_millis: 0,
    greeting_duration_millis: 0,
    greeting_silence_duration_millis: 0,
    greeting_total_analysis_time_millis: 0,
    initial_silence_millis: 0,
    maximum_number_of_words: 0,
    maximum_word_length_millis: 0,
    silence_threshold: 0,
    total_analysis_time_millis: 0
  },
  audio_url: '',
  client_state: '',
  command_id: '',
  custom_headers: [
    {
      name: '',
      value: ''
    }
  ],
  from: '',
  from_display_name: '',
  media_name: '',
  sip_auth_password: '',
  sip_auth_username: '',
  target_leg_client_state: '',
  time_limit_secs: 0,
  timeout_secs: 0,
  to: '',
  webhook_url: '',
  webhook_url_method: ''
});

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}}/calls/:call_control_id/actions/transfer',
  headers: {'content-type': 'application/json'},
  data: {
    answering_machine_detection: '',
    answering_machine_detection_config: {
      after_greeting_silence_millis: 0,
      between_words_silence_millis: 0,
      greeting_duration_millis: 0,
      greeting_silence_duration_millis: 0,
      greeting_total_analysis_time_millis: 0,
      initial_silence_millis: 0,
      maximum_number_of_words: 0,
      maximum_word_length_millis: 0,
      silence_threshold: 0,
      total_analysis_time_millis: 0
    },
    audio_url: '',
    client_state: '',
    command_id: '',
    custom_headers: [{name: '', value: ''}],
    from: '',
    from_display_name: '',
    media_name: '',
    sip_auth_password: '',
    sip_auth_username: '',
    target_leg_client_state: '',
    time_limit_secs: 0,
    timeout_secs: 0,
    to: '',
    webhook_url: '',
    webhook_url_method: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/calls/:call_control_id/actions/transfer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"answering_machine_detection":"","answering_machine_detection_config":{"after_greeting_silence_millis":0,"between_words_silence_millis":0,"greeting_duration_millis":0,"greeting_silence_duration_millis":0,"greeting_total_analysis_time_millis":0,"initial_silence_millis":0,"maximum_number_of_words":0,"maximum_word_length_millis":0,"silence_threshold":0,"total_analysis_time_millis":0},"audio_url":"","client_state":"","command_id":"","custom_headers":[{"name":"","value":""}],"from":"","from_display_name":"","media_name":"","sip_auth_password":"","sip_auth_username":"","target_leg_client_state":"","time_limit_secs":0,"timeout_secs":0,"to":"","webhook_url":"","webhook_url_method":""}'
};

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 = @{ @"answering_machine_detection": @"",
                              @"answering_machine_detection_config": @{ @"after_greeting_silence_millis": @0, @"between_words_silence_millis": @0, @"greeting_duration_millis": @0, @"greeting_silence_duration_millis": @0, @"greeting_total_analysis_time_millis": @0, @"initial_silence_millis": @0, @"maximum_number_of_words": @0, @"maximum_word_length_millis": @0, @"silence_threshold": @0, @"total_analysis_time_millis": @0 },
                              @"audio_url": @"",
                              @"client_state": @"",
                              @"command_id": @"",
                              @"custom_headers": @[ @{ @"name": @"", @"value": @"" } ],
                              @"from": @"",
                              @"from_display_name": @"",
                              @"media_name": @"",
                              @"sip_auth_password": @"",
                              @"sip_auth_username": @"",
                              @"target_leg_client_state": @"",
                              @"time_limit_secs": @0,
                              @"timeout_secs": @0,
                              @"to": @"",
                              @"webhook_url": @"",
                              @"webhook_url_method": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calls/:call_control_id/actions/transfer"]
                                                       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}}/calls/:call_control_id/actions/transfer" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/calls/:call_control_id/actions/transfer",
  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([
    'answering_machine_detection' => '',
    'answering_machine_detection_config' => [
        'after_greeting_silence_millis' => 0,
        'between_words_silence_millis' => 0,
        'greeting_duration_millis' => 0,
        'greeting_silence_duration_millis' => 0,
        'greeting_total_analysis_time_millis' => 0,
        'initial_silence_millis' => 0,
        'maximum_number_of_words' => 0,
        'maximum_word_length_millis' => 0,
        'silence_threshold' => 0,
        'total_analysis_time_millis' => 0
    ],
    'audio_url' => '',
    'client_state' => '',
    'command_id' => '',
    'custom_headers' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'from' => '',
    'from_display_name' => '',
    'media_name' => '',
    'sip_auth_password' => '',
    'sip_auth_username' => '',
    'target_leg_client_state' => '',
    'time_limit_secs' => 0,
    'timeout_secs' => 0,
    'to' => '',
    'webhook_url' => '',
    'webhook_url_method' => ''
  ]),
  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}}/calls/:call_control_id/actions/transfer', [
  'body' => '{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "target_leg_client_state": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/calls/:call_control_id/actions/transfer');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'answering_machine_detection' => '',
  'answering_machine_detection_config' => [
    'after_greeting_silence_millis' => 0,
    'between_words_silence_millis' => 0,
    'greeting_duration_millis' => 0,
    'greeting_silence_duration_millis' => 0,
    'greeting_total_analysis_time_millis' => 0,
    'initial_silence_millis' => 0,
    'maximum_number_of_words' => 0,
    'maximum_word_length_millis' => 0,
    'silence_threshold' => 0,
    'total_analysis_time_millis' => 0
  ],
  'audio_url' => '',
  'client_state' => '',
  'command_id' => '',
  'custom_headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'from' => '',
  'from_display_name' => '',
  'media_name' => '',
  'sip_auth_password' => '',
  'sip_auth_username' => '',
  'target_leg_client_state' => '',
  'time_limit_secs' => 0,
  'timeout_secs' => 0,
  'to' => '',
  'webhook_url' => '',
  'webhook_url_method' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'answering_machine_detection' => '',
  'answering_machine_detection_config' => [
    'after_greeting_silence_millis' => 0,
    'between_words_silence_millis' => 0,
    'greeting_duration_millis' => 0,
    'greeting_silence_duration_millis' => 0,
    'greeting_total_analysis_time_millis' => 0,
    'initial_silence_millis' => 0,
    'maximum_number_of_words' => 0,
    'maximum_word_length_millis' => 0,
    'silence_threshold' => 0,
    'total_analysis_time_millis' => 0
  ],
  'audio_url' => '',
  'client_state' => '',
  'command_id' => '',
  'custom_headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'from' => '',
  'from_display_name' => '',
  'media_name' => '',
  'sip_auth_password' => '',
  'sip_auth_username' => '',
  'target_leg_client_state' => '',
  'time_limit_secs' => 0,
  'timeout_secs' => 0,
  'to' => '',
  'webhook_url' => '',
  'webhook_url_method' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calls/:call_control_id/actions/transfer');
$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}}/calls/:call_control_id/actions/transfer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "target_leg_client_state": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calls/:call_control_id/actions/transfer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "target_leg_client_state": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/calls/:call_control_id/actions/transfer", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/calls/:call_control_id/actions/transfer"

payload = {
    "answering_machine_detection": "",
    "answering_machine_detection_config": {
        "after_greeting_silence_millis": 0,
        "between_words_silence_millis": 0,
        "greeting_duration_millis": 0,
        "greeting_silence_duration_millis": 0,
        "greeting_total_analysis_time_millis": 0,
        "initial_silence_millis": 0,
        "maximum_number_of_words": 0,
        "maximum_word_length_millis": 0,
        "silence_threshold": 0,
        "total_analysis_time_millis": 0
    },
    "audio_url": "",
    "client_state": "",
    "command_id": "",
    "custom_headers": [
        {
            "name": "",
            "value": ""
        }
    ],
    "from": "",
    "from_display_name": "",
    "media_name": "",
    "sip_auth_password": "",
    "sip_auth_username": "",
    "target_leg_client_state": "",
    "time_limit_secs": 0,
    "timeout_secs": 0,
    "to": "",
    "webhook_url": "",
    "webhook_url_method": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/calls/:call_control_id/actions/transfer"

payload <- "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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}}/calls/:call_control_id/actions/transfer")

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  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\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/calls/:call_control_id/actions/transfer') do |req|
  req.body = "{\n  \"answering_machine_detection\": \"\",\n  \"answering_machine_detection_config\": {\n    \"after_greeting_silence_millis\": 0,\n    \"between_words_silence_millis\": 0,\n    \"greeting_duration_millis\": 0,\n    \"greeting_silence_duration_millis\": 0,\n    \"greeting_total_analysis_time_millis\": 0,\n    \"initial_silence_millis\": 0,\n    \"maximum_number_of_words\": 0,\n    \"maximum_word_length_millis\": 0,\n    \"silence_threshold\": 0,\n    \"total_analysis_time_millis\": 0\n  },\n  \"audio_url\": \"\",\n  \"client_state\": \"\",\n  \"command_id\": \"\",\n  \"custom_headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"from\": \"\",\n  \"from_display_name\": \"\",\n  \"media_name\": \"\",\n  \"sip_auth_password\": \"\",\n  \"sip_auth_username\": \"\",\n  \"target_leg_client_state\": \"\",\n  \"time_limit_secs\": 0,\n  \"timeout_secs\": 0,\n  \"to\": \"\",\n  \"webhook_url\": \"\",\n  \"webhook_url_method\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/calls/:call_control_id/actions/transfer";

    let payload = json!({
        "answering_machine_detection": "",
        "answering_machine_detection_config": json!({
            "after_greeting_silence_millis": 0,
            "between_words_silence_millis": 0,
            "greeting_duration_millis": 0,
            "greeting_silence_duration_millis": 0,
            "greeting_total_analysis_time_millis": 0,
            "initial_silence_millis": 0,
            "maximum_number_of_words": 0,
            "maximum_word_length_millis": 0,
            "silence_threshold": 0,
            "total_analysis_time_millis": 0
        }),
        "audio_url": "",
        "client_state": "",
        "command_id": "",
        "custom_headers": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "from": "",
        "from_display_name": "",
        "media_name": "",
        "sip_auth_password": "",
        "sip_auth_username": "",
        "target_leg_client_state": "",
        "time_limit_secs": 0,
        "timeout_secs": 0,
        "to": "",
        "webhook_url": "",
        "webhook_url_method": ""
    });

    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 '{
  "answering_machine_detection": "",
  "answering_machine_detection_config": {
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  },
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "from": "",
  "from_display_name": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "target_leg_client_state": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
}' |  \
  http POST {{baseUrl}}/calls/:call_control_id/actions/transfer \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "answering_machine_detection": "",\n  "answering_machine_detection_config": {\n    "after_greeting_silence_millis": 0,\n    "between_words_silence_millis": 0,\n    "greeting_duration_millis": 0,\n    "greeting_silence_duration_millis": 0,\n    "greeting_total_analysis_time_millis": 0,\n    "initial_silence_millis": 0,\n    "maximum_number_of_words": 0,\n    "maximum_word_length_millis": 0,\n    "silence_threshold": 0,\n    "total_analysis_time_millis": 0\n  },\n  "audio_url": "",\n  "client_state": "",\n  "command_id": "",\n  "custom_headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "from": "",\n  "from_display_name": "",\n  "media_name": "",\n  "sip_auth_password": "",\n  "sip_auth_username": "",\n  "target_leg_client_state": "",\n  "time_limit_secs": 0,\n  "timeout_secs": 0,\n  "to": "",\n  "webhook_url": "",\n  "webhook_url_method": ""\n}' \
  --output-document \
  - {{baseUrl}}/calls/:call_control_id/actions/transfer

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "answering_machine_detection": "",
  "answering_machine_detection_config": [
    "after_greeting_silence_millis": 0,
    "between_words_silence_millis": 0,
    "greeting_duration_millis": 0,
    "greeting_silence_duration_millis": 0,
    "greeting_total_analysis_time_millis": 0,
    "initial_silence_millis": 0,
    "maximum_number_of_words": 0,
    "maximum_word_length_millis": 0,
    "silence_threshold": 0,
    "total_analysis_time_millis": 0
  ],
  "audio_url": "",
  "client_state": "",
  "command_id": "",
  "custom_headers": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "from": "",
  "from_display_name": "",
  "media_name": "",
  "sip_auth_password": "",
  "sip_auth_username": "",
  "target_leg_client_state": "",
  "time_limit_secs": 0,
  "timeout_secs": 0,
  "to": "",
  "webhook_url": "",
  "webhook_url_method": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/calls/:call_control_id/actions/transfer")! 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}}/call_control_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  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/call_control_applications" {:content-type :json
                                                                      :form-params {:active false
                                                                                    :anchorsite_override ""
                                                                                    :application_name ""
                                                                                    :dtmf_type ""
                                                                                    :first_command_timeout false
                                                                                    :first_command_timeout_secs 0
                                                                                    :inbound {:channel_limit 0
                                                                                              :sip_subdomain ""
                                                                                              :sip_subdomain_receive_settings ""}
                                                                                    :outbound {:channel_limit 0
                                                                                               :outbound_voice_profile_id ""}
                                                                                    :webhook_api_version ""
                                                                                    :webhook_event_failover_url ""
                                                                                    :webhook_event_url ""
                                                                                    :webhook_timeout_secs 0}})

require "http/client"

url = "{{baseUrl}}/call_control_applications"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\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}}/call_control_applications"),
    Content = new StringContent("{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/call_control_applications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/call_control_applications"

	payload := strings.NewReader("{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\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/call_control_applications HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 476

{
  "active": false,
  "anchorsite_override": "",
  "application_name": "",
  "dtmf_type": "",
  "first_command_timeout": false,
  "first_command_timeout_secs": 0,
  "inbound": {
    "channel_limit": 0,
    "sip_subdomain": "",
    "sip_subdomain_receive_settings": ""
  },
  "outbound": {
    "channel_limit": 0,
    "outbound_voice_profile_id": ""
  },
  "webhook_api_version": "",
  "webhook_event_failover_url": "",
  "webhook_event_url": "",
  "webhook_timeout_secs": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/call_control_applications")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/call_control_applications"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/call_control_applications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/call_control_applications")
  .header("content-type", "application/json")
  .body("{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}")
  .asString();

const data = JSON.stringify({
  active: false,
  anchorsite_override: '',
  application_name: '',
  dtmf_type: '',
  first_command_timeout: false,
  first_command_timeout_secs: 0,
  inbound: {
    channel_limit: 0,
    sip_subdomain: '',
    sip_subdomain_receive_settings: ''
  },
  outbound: {
    channel_limit: 0,
    outbound_voice_profile_id: ''
  },
  webhook_api_version: '',
  webhook_event_failover_url: '',
  webhook_event_url: '',
  webhook_timeout_secs: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/call_control_applications');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/call_control_applications',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    anchorsite_override: '',
    application_name: '',
    dtmf_type: '',
    first_command_timeout: false,
    first_command_timeout_secs: 0,
    inbound: {channel_limit: 0, sip_subdomain: '', sip_subdomain_receive_settings: ''},
    outbound: {channel_limit: 0, outbound_voice_profile_id: ''},
    webhook_api_version: '',
    webhook_event_failover_url: '',
    webhook_event_url: '',
    webhook_timeout_secs: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/call_control_applications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"anchorsite_override":"","application_name":"","dtmf_type":"","first_command_timeout":false,"first_command_timeout_secs":0,"inbound":{"channel_limit":0,"sip_subdomain":"","sip_subdomain_receive_settings":""},"outbound":{"channel_limit":0,"outbound_voice_profile_id":""},"webhook_api_version":"","webhook_event_failover_url":"","webhook_event_url":"","webhook_timeout_secs":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/call_control_applications',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "active": false,\n  "anchorsite_override": "",\n  "application_name": "",\n  "dtmf_type": "",\n  "first_command_timeout": false,\n  "first_command_timeout_secs": 0,\n  "inbound": {\n    "channel_limit": 0,\n    "sip_subdomain": "",\n    "sip_subdomain_receive_settings": ""\n  },\n  "outbound": {\n    "channel_limit": 0,\n    "outbound_voice_profile_id": ""\n  },\n  "webhook_api_version": "",\n  "webhook_event_failover_url": "",\n  "webhook_event_url": "",\n  "webhook_timeout_secs": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/call_control_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/call_control_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({
  active: false,
  anchorsite_override: '',
  application_name: '',
  dtmf_type: '',
  first_command_timeout: false,
  first_command_timeout_secs: 0,
  inbound: {channel_limit: 0, sip_subdomain: '', sip_subdomain_receive_settings: ''},
  outbound: {channel_limit: 0, outbound_voice_profile_id: ''},
  webhook_api_version: '',
  webhook_event_failover_url: '',
  webhook_event_url: '',
  webhook_timeout_secs: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/call_control_applications',
  headers: {'content-type': 'application/json'},
  body: {
    active: false,
    anchorsite_override: '',
    application_name: '',
    dtmf_type: '',
    first_command_timeout: false,
    first_command_timeout_secs: 0,
    inbound: {channel_limit: 0, sip_subdomain: '', sip_subdomain_receive_settings: ''},
    outbound: {channel_limit: 0, outbound_voice_profile_id: ''},
    webhook_api_version: '',
    webhook_event_failover_url: '',
    webhook_event_url: '',
    webhook_timeout_secs: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/call_control_applications');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  active: false,
  anchorsite_override: '',
  application_name: '',
  dtmf_type: '',
  first_command_timeout: false,
  first_command_timeout_secs: 0,
  inbound: {
    channel_limit: 0,
    sip_subdomain: '',
    sip_subdomain_receive_settings: ''
  },
  outbound: {
    channel_limit: 0,
    outbound_voice_profile_id: ''
  },
  webhook_api_version: '',
  webhook_event_failover_url: '',
  webhook_event_url: '',
  webhook_timeout_secs: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/call_control_applications',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    anchorsite_override: '',
    application_name: '',
    dtmf_type: '',
    first_command_timeout: false,
    first_command_timeout_secs: 0,
    inbound: {channel_limit: 0, sip_subdomain: '', sip_subdomain_receive_settings: ''},
    outbound: {channel_limit: 0, outbound_voice_profile_id: ''},
    webhook_api_version: '',
    webhook_event_failover_url: '',
    webhook_event_url: '',
    webhook_timeout_secs: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/call_control_applications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"anchorsite_override":"","application_name":"","dtmf_type":"","first_command_timeout":false,"first_command_timeout_secs":0,"inbound":{"channel_limit":0,"sip_subdomain":"","sip_subdomain_receive_settings":""},"outbound":{"channel_limit":0,"outbound_voice_profile_id":""},"webhook_api_version":"","webhook_event_failover_url":"","webhook_event_url":"","webhook_timeout_secs":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"active": @NO,
                              @"anchorsite_override": @"",
                              @"application_name": @"",
                              @"dtmf_type": @"",
                              @"first_command_timeout": @NO,
                              @"first_command_timeout_secs": @0,
                              @"inbound": @{ @"channel_limit": @0, @"sip_subdomain": @"", @"sip_subdomain_receive_settings": @"" },
                              @"outbound": @{ @"channel_limit": @0, @"outbound_voice_profile_id": @"" },
                              @"webhook_api_version": @"",
                              @"webhook_event_failover_url": @"",
                              @"webhook_event_url": @"",
                              @"webhook_timeout_secs": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/call_control_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}}/call_control_applications" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/call_control_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([
    'active' => null,
    'anchorsite_override' => '',
    'application_name' => '',
    'dtmf_type' => '',
    'first_command_timeout' => null,
    'first_command_timeout_secs' => 0,
    'inbound' => [
        'channel_limit' => 0,
        'sip_subdomain' => '',
        'sip_subdomain_receive_settings' => ''
    ],
    'outbound' => [
        'channel_limit' => 0,
        'outbound_voice_profile_id' => ''
    ],
    'webhook_api_version' => '',
    'webhook_event_failover_url' => '',
    'webhook_event_url' => '',
    'webhook_timeout_secs' => 0
  ]),
  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}}/call_control_applications', [
  'body' => '{
  "active": false,
  "anchorsite_override": "",
  "application_name": "",
  "dtmf_type": "",
  "first_command_timeout": false,
  "first_command_timeout_secs": 0,
  "inbound": {
    "channel_limit": 0,
    "sip_subdomain": "",
    "sip_subdomain_receive_settings": ""
  },
  "outbound": {
    "channel_limit": 0,
    "outbound_voice_profile_id": ""
  },
  "webhook_api_version": "",
  "webhook_event_failover_url": "",
  "webhook_event_url": "",
  "webhook_timeout_secs": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/call_control_applications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'active' => null,
  'anchorsite_override' => '',
  'application_name' => '',
  'dtmf_type' => '',
  'first_command_timeout' => null,
  'first_command_timeout_secs' => 0,
  'inbound' => [
    'channel_limit' => 0,
    'sip_subdomain' => '',
    'sip_subdomain_receive_settings' => ''
  ],
  'outbound' => [
    'channel_limit' => 0,
    'outbound_voice_profile_id' => ''
  ],
  'webhook_api_version' => '',
  'webhook_event_failover_url' => '',
  'webhook_event_url' => '',
  'webhook_timeout_secs' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'active' => null,
  'anchorsite_override' => '',
  'application_name' => '',
  'dtmf_type' => '',
  'first_command_timeout' => null,
  'first_command_timeout_secs' => 0,
  'inbound' => [
    'channel_limit' => 0,
    'sip_subdomain' => '',
    'sip_subdomain_receive_settings' => ''
  ],
  'outbound' => [
    'channel_limit' => 0,
    'outbound_voice_profile_id' => ''
  ],
  'webhook_api_version' => '',
  'webhook_event_failover_url' => '',
  'webhook_event_url' => '',
  'webhook_timeout_secs' => 0
]));
$request->setRequestUrl('{{baseUrl}}/call_control_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}}/call_control_applications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "anchorsite_override": "",
  "application_name": "",
  "dtmf_type": "",
  "first_command_timeout": false,
  "first_command_timeout_secs": 0,
  "inbound": {
    "channel_limit": 0,
    "sip_subdomain": "",
    "sip_subdomain_receive_settings": ""
  },
  "outbound": {
    "channel_limit": 0,
    "outbound_voice_profile_id": ""
  },
  "webhook_api_version": "",
  "webhook_event_failover_url": "",
  "webhook_event_url": "",
  "webhook_timeout_secs": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/call_control_applications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "anchorsite_override": "",
  "application_name": "",
  "dtmf_type": "",
  "first_command_timeout": false,
  "first_command_timeout_secs": 0,
  "inbound": {
    "channel_limit": 0,
    "sip_subdomain": "",
    "sip_subdomain_receive_settings": ""
  },
  "outbound": {
    "channel_limit": 0,
    "outbound_voice_profile_id": ""
  },
  "webhook_api_version": "",
  "webhook_event_failover_url": "",
  "webhook_event_url": "",
  "webhook_timeout_secs": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/call_control_applications", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/call_control_applications"

payload = {
    "active": False,
    "anchorsite_override": "",
    "application_name": "",
    "dtmf_type": "",
    "first_command_timeout": False,
    "first_command_timeout_secs": 0,
    "inbound": {
        "channel_limit": 0,
        "sip_subdomain": "",
        "sip_subdomain_receive_settings": ""
    },
    "outbound": {
        "channel_limit": 0,
        "outbound_voice_profile_id": ""
    },
    "webhook_api_version": "",
    "webhook_event_failover_url": "",
    "webhook_event_url": "",
    "webhook_timeout_secs": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/call_control_applications"

payload <- "{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\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}}/call_control_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  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\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/call_control_applications') do |req|
  req.body = "{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/call_control_applications";

    let payload = json!({
        "active": false,
        "anchorsite_override": "",
        "application_name": "",
        "dtmf_type": "",
        "first_command_timeout": false,
        "first_command_timeout_secs": 0,
        "inbound": json!({
            "channel_limit": 0,
            "sip_subdomain": "",
            "sip_subdomain_receive_settings": ""
        }),
        "outbound": json!({
            "channel_limit": 0,
            "outbound_voice_profile_id": ""
        }),
        "webhook_api_version": "",
        "webhook_event_failover_url": "",
        "webhook_event_url": "",
        "webhook_timeout_secs": 0
    });

    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 '{
  "active": false,
  "anchorsite_override": "",
  "application_name": "",
  "dtmf_type": "",
  "first_command_timeout": false,
  "first_command_timeout_secs": 0,
  "inbound": {
    "channel_limit": 0,
    "sip_subdomain": "",
    "sip_subdomain_receive_settings": ""
  },
  "outbound": {
    "channel_limit": 0,
    "outbound_voice_profile_id": ""
  },
  "webhook_api_version": "",
  "webhook_event_failover_url": "",
  "webhook_event_url": "",
  "webhook_timeout_secs": 0
}' |  \
  http POST {{baseUrl}}/call_control_applications \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "active": false,\n  "anchorsite_override": "",\n  "application_name": "",\n  "dtmf_type": "",\n  "first_command_timeout": false,\n  "first_command_timeout_secs": 0,\n  "inbound": {\n    "channel_limit": 0,\n    "sip_subdomain": "",\n    "sip_subdomain_receive_settings": ""\n  },\n  "outbound": {\n    "channel_limit": 0,\n    "outbound_voice_profile_id": ""\n  },\n  "webhook_api_version": "",\n  "webhook_event_failover_url": "",\n  "webhook_event_url": "",\n  "webhook_timeout_secs": 0\n}' \
  --output-document \
  - {{baseUrl}}/call_control_applications

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "active": false,
  "anchorsite_override": "",
  "application_name": "",
  "dtmf_type": "",
  "first_command_timeout": false,
  "first_command_timeout_secs": 0,
  "inbound": [
    "channel_limit": 0,
    "sip_subdomain": "",
    "sip_subdomain_receive_settings": ""
  ],
  "outbound": [
    "channel_limit": 0,
    "outbound_voice_profile_id": ""
  ],
  "webhook_api_version": "",
  "webhook_event_failover_url": "",
  "webhook_event_url": "",
  "webhook_timeout_secs": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/call_control_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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/call_control_applications/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/call_control_applications/:id")

require "http/client"

url = "{{baseUrl}}/call_control_applications/:id"

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}}/call_control_applications/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/call_control_applications/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/call_control_applications/:id"

	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/call_control_applications/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/call_control_applications/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/call_control_applications/:id"))
    .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}}/call_control_applications/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/call_control_applications/:id")
  .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}}/call_control_applications/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/call_control_applications/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/call_control_applications/:id';
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}}/call_control_applications/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/call_control_applications/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/call_control_applications/:id',
  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}}/call_control_applications/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/call_control_applications/:id');

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}}/call_control_applications/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/call_control_applications/:id';
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}}/call_control_applications/:id"]
                                                       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}}/call_control_applications/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/call_control_applications/:id",
  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}}/call_control_applications/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/call_control_applications/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/call_control_applications/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/call_control_applications/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/call_control_applications/:id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/call_control_applications/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/call_control_applications/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/call_control_applications/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/call_control_applications/:id")

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/call_control_applications/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/call_control_applications/:id";

    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}}/call_control_applications/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/call_control_applications/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/call_control_applications/:id")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/call_control_applications");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/call_control_applications")

require "http/client"

url = "{{baseUrl}}/call_control_applications"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/call_control_applications"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/call_control_applications");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/call_control_applications"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/call_control_applications HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/call_control_applications")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/call_control_applications"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/call_control_applications")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/call_control_applications")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/call_control_applications');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/call_control_applications'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/call_control_applications';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/call_control_applications',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/call_control_applications")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/call_control_applications',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/call_control_applications'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/call_control_applications');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/call_control_applications'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/call_control_applications';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/call_control_applications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/call_control_applications" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/call_control_applications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/call_control_applications');

echo $response->getBody();

setUrl('{{baseUrl}}/call_control_applications');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/call_control_applications');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/call_control_applications' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/call_control_applications' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/call_control_applications")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/call_control_applications"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/call_control_applications"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/call_control_applications")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/call_control_applications') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/call_control_applications";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/call_control_applications

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/call_control_applications

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/call_control_applications")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/call_control_applications/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/call_control_applications/:id")

require "http/client"

url = "{{baseUrl}}/call_control_applications/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/call_control_applications/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/call_control_applications/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/call_control_applications/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/call_control_applications/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/call_control_applications/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/call_control_applications/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/call_control_applications/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/call_control_applications/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/call_control_applications/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/call_control_applications/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/call_control_applications/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/call_control_applications/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/call_control_applications/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/call_control_applications/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/call_control_applications/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/call_control_applications/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/call_control_applications/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/call_control_applications/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/call_control_applications/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/call_control_applications/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/call_control_applications/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/call_control_applications/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/call_control_applications/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/call_control_applications/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/call_control_applications/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/call_control_applications/:id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/call_control_applications/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/call_control_applications/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/call_control_applications/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/call_control_applications/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/call_control_applications/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/call_control_applications/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/call_control_applications/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/call_control_applications/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/call_control_applications/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/call_control_applications/:id");

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  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/call_control_applications/:id" {:content-type :json
                                                                           :form-params {:active false
                                                                                         :anchorsite_override ""
                                                                                         :application_name ""
                                                                                         :dtmf_type ""
                                                                                         :first_command_timeout false
                                                                                         :first_command_timeout_secs 0
                                                                                         :inbound {:channel_limit 0
                                                                                                   :sip_subdomain ""
                                                                                                   :sip_subdomain_receive_settings ""}
                                                                                         :outbound {:channel_limit 0
                                                                                                    :outbound_voice_profile_id ""}
                                                                                         :webhook_api_version ""
                                                                                         :webhook_event_failover_url ""
                                                                                         :webhook_event_url ""
                                                                                         :webhook_timeout_secs 0}})

require "http/client"

url = "{{baseUrl}}/call_control_applications/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/call_control_applications/:id"),
    Content = new StringContent("{\n  \"active\": false,\n  \"anchorsite_override\": \"\",\n  \"application_name\": \"\",\n  \"dtmf_type\": \"\",\n  \"first_command_timeout\": false,\n  \"first_command_timeout_secs\": 0,\n  \"inbound\": {\n    \"channel_limit\": 0,\n    \"sip_subdomain\": \"\",\n    \"sip_subdomain_receive_settings\": \"\"\n  },\n  \"outbound\": {\n    \"channel_limit\": 0,\n    \"outbound_voice_profile_id\": \"\"\n  },\n  \"webhook_api_version\": \"\",\n  \"webhook_event_failover_url\": \"\",\n  \"webhook_event_url\": \"\",\n  \"webhook_timeout_secs\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}