CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "FactorFriendlyName=&FactorType=&Identity=&Ttl=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens" {:form-params {:FactorFriendlyName ""
                                                                                               :FactorType ""
                                                                                               :Identity ""
                                                                                               :Ttl ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "FactorFriendlyName=&FactorType=&Identity=&Ttl="

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}}/v2/Services/:ServiceSid/AccessTokens"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "FactorFriendlyName", "" },
        { "FactorType", "" },
        { "Identity", "" },
        { "Ttl", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "FactorFriendlyName=&FactorType=&Identity=&Ttl=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens"

	payload := strings.NewReader("FactorFriendlyName=&FactorType=&Identity=&Ttl=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/AccessTokens HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 46

FactorFriendlyName=&FactorType=&Identity=&Ttl=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("FactorFriendlyName=&FactorType=&Identity=&Ttl=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("FactorFriendlyName=&FactorType=&Identity=&Ttl="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "FactorFriendlyName=&FactorType=&Identity=&Ttl=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("FactorFriendlyName=&FactorType=&Identity=&Ttl=")
  .asString();

const data = 'FactorFriendlyName=&FactorType=&Identity=&Ttl=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('FactorFriendlyName', '');
encodedParams.set('FactorType', '');
encodedParams.set('Identity', '');
encodedParams.set('Ttl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({FactorFriendlyName: '', FactorType: '', Identity: '', Ttl: ''})
};

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}}/v2/Services/:ServiceSid/AccessTokens',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    FactorFriendlyName: '',
    FactorType: '',
    Identity: '',
    Ttl: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "FactorFriendlyName=&FactorType=&Identity=&Ttl=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({FactorFriendlyName: '', FactorType: '', Identity: '', Ttl: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {FactorFriendlyName: '', FactorType: '', Identity: '', Ttl: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens');

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

req.form({
  FactorFriendlyName: '',
  FactorType: '',
  Identity: '',
  Ttl: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('FactorFriendlyName', '');
encodedParams.set('FactorType', '');
encodedParams.set('Identity', '');
encodedParams.set('Ttl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('FactorFriendlyName', '');
encodedParams.set('FactorType', '');
encodedParams.set('Identity', '');
encodedParams.set('Ttl', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"FactorFriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FactorType=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Ttl=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens"]
                                                       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}}/v2/Services/:ServiceSid/AccessTokens" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "FactorFriendlyName=&FactorType=&Identity=&Ttl=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "FactorFriendlyName=&FactorType=&Identity=&Ttl=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens', [
  'form_params' => [
    'FactorFriendlyName' => '',
    'FactorType' => '',
    'Identity' => '',
    'Ttl' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'FactorFriendlyName' => '',
  'FactorType' => '',
  'Identity' => '',
  'Ttl' => ''
]);

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

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

append(new http\QueryString([
  'FactorFriendlyName' => '',
  'FactorType' => '',
  'Identity' => '',
  'Ttl' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FactorFriendlyName=&FactorType=&Identity=&Ttl='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FactorFriendlyName=&FactorType=&Identity=&Ttl='

import http.client

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

payload = "FactorFriendlyName=&FactorType=&Identity=&Ttl="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/AccessTokens", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens"

payload = {
    "FactorFriendlyName": "",
    "FactorType": "",
    "Identity": "",
    "Ttl": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens"

payload <- "FactorFriendlyName=&FactorType=&Identity=&Ttl="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens")

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

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

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

require 'faraday'

data = {
  :FactorFriendlyName => "",
  :FactorType => "",
  :Identity => "",
  :Ttl => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/AccessTokens') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "FactorFriendlyName": "",
        "FactorType": "",
        "Identity": "",
        "Ttl": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/AccessTokens \
  content-type:application/x-www-form-urlencoded \
  FactorFriendlyName='' \
  FactorType='' \
  Identity='' \
  Ttl=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'FactorFriendlyName=&FactorType=&Identity=&Ttl=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/AccessTokens

import Foundation

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

let postData = NSMutableData(data: "FactorFriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&FactorType=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&Ttl=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens")! 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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Interval=&Max=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets" {:form-params {:Interval ""
                                                                                                                   :Max ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Interval=&Max="

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Interval", "" },
        { "Max", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Interval=&Max=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"

	payload := strings.NewReader("Interval=&Max=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 14

Interval=&Max=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Interval=&Max=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Interval=&Max="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Interval=&Max=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Interval=&Max=")
  .asString();

const data = 'Interval=&Max=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Interval', '');
encodedParams.set('Max', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Interval: '', Max: ''})
};

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Interval: '',
    Max: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Interval=&Max=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({Interval: '', Max: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Interval: '', Max: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets');

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

req.form({
  Interval: '',
  Max: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Interval', '');
encodedParams.set('Max', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Interval', '');
encodedParams.set('Max', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Interval=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Max=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Interval=&Max=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Interval=&Max=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets', [
  'form_params' => [
    'Interval' => '',
    'Max' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Interval' => '',
  'Max' => ''
]);

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

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

append(new http\QueryString([
  'Interval' => '',
  'Max' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Interval=&Max='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Interval=&Max='

import http.client

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

payload = "Interval=&Max="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"

payload <- "Interval=&Max="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")

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

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

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

require 'faraday'

data = {
  :Interval => "",
  :Max => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets";

    let payload = json!({
        "Interval": "",
        "Max": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets \
  content-type:application/x-www-form-urlencoded \
  Interval='' \
  Max=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Interval=&Max=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets

import Foundation

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

let postData = NSMutableData(data: "Interval=".data(using: String.Encoding.utf8)!)
postData.append("&Max=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")! 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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges" {:form-params {:AuthPayload ""
                                                                                                                :Details.Fields ""
                                                                                                                :Details.Message ""
                                                                                                                :ExpirationDate ""
                                                                                                                :FactorSid ""
                                                                                                                :HiddenDetails ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails="

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AuthPayload", "" },
        { "Details.Fields", "" },
        { "Details.Message", "" },
        { "ExpirationDate", "" },
        { "FactorSid", "" },
        { "HiddenDetails", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"

	payload := strings.NewReader("AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 87

AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=")
  .asString();

const data = 'AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AuthPayload', '');
encodedParams.set('Details.Fields', '');
encodedParams.set('Details.Message', '');
encodedParams.set('ExpirationDate', '');
encodedParams.set('FactorSid', '');
encodedParams.set('HiddenDetails', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AuthPayload: '',
    'Details.Fields': '',
    'Details.Message': '',
    ExpirationDate: '',
    FactorSid: '',
    HiddenDetails: ''
  })
};

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AuthPayload: '',
    'Details.Fields': '',
    'Details.Message': '',
    ExpirationDate: '',
    FactorSid: '',
    HiddenDetails: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({
  AuthPayload: '',
  'Details.Fields': '',
  'Details.Message': '',
  ExpirationDate: '',
  FactorSid: '',
  HiddenDetails: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AuthPayload: '',
    'Details.Fields': '',
    'Details.Message': '',
    ExpirationDate: '',
    FactorSid: '',
    HiddenDetails: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges');

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

req.form({
  AuthPayload: '',
  'Details.Fields': '',
  'Details.Message': '',
  ExpirationDate: '',
  FactorSid: '',
  HiddenDetails: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('AuthPayload', '');
encodedParams.set('Details.Fields', '');
encodedParams.set('Details.Message', '');
encodedParams.set('ExpirationDate', '');
encodedParams.set('FactorSid', '');
encodedParams.set('HiddenDetails', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('AuthPayload', '');
encodedParams.set('Details.Fields', '');
encodedParams.set('Details.Message', '');
encodedParams.set('ExpirationDate', '');
encodedParams.set('FactorSid', '');
encodedParams.set('HiddenDetails', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"AuthPayload=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Details.Fields=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Details.Message=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ExpirationDate=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FactorSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&HiddenDetails=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges', [
  'form_params' => [
    'AuthPayload' => '',
    'Details.Fields' => '',
    'Details.Message' => '',
    'ExpirationDate' => '',
    'FactorSid' => '',
    'HiddenDetails' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AuthPayload' => '',
  'Details.Fields' => '',
  'Details.Message' => '',
  'ExpirationDate' => '',
  'FactorSid' => '',
  'HiddenDetails' => ''
]);

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

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

append(new http\QueryString([
  'AuthPayload' => '',
  'Details.Fields' => '',
  'Details.Message' => '',
  'ExpirationDate' => '',
  'FactorSid' => '',
  'HiddenDetails' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails='

import http.client

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

payload = "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"

payload = {
    "AuthPayload": "",
    "Details.Fields": "",
    "Details.Message": "",
    "ExpirationDate": "",
    "FactorSid": "",
    "HiddenDetails": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"

payload <- "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails="

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

require 'faraday'

data = {
  :AuthPayload => "",
  :Details.Fields => "",
  :Details.Message => "",
  :ExpirationDate => "",
  :FactorSid => "",
  :HiddenDetails => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges";

    let payload = json!({
        "AuthPayload": "",
        "Details.Fields": "",
        "Details.Message": "",
        "ExpirationDate": "",
        "FactorSid": "",
        "HiddenDetails": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges \
  content-type:application/x-www-form-urlencoded \
  AuthPayload='' \
  Details.Fields='' \
  Details.Message='' \
  ExpirationDate='' \
  FactorSid='' \
  HiddenDetails=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AuthPayload=&Details.Fields=&Details.Message=&ExpirationDate=&FactorSid=&HiddenDetails=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges

import Foundation

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

let postData = NSMutableData(data: "AuthPayload=".data(using: String.Encoding.utf8)!)
postData.append("&Details.Fields=".data(using: String.Encoding.utf8)!)
postData.append("&Details.Message=".data(using: String.Encoding.utf8)!)
postData.append("&ExpirationDate=".data(using: String.Encoding.utf8)!)
postData.append("&FactorSid=".data(using: String.Encoding.utf8)!)
postData.append("&HiddenDetails=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")! 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}}/v2/Services/:ServiceSid/Entities");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Identity=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/Entities" {:form-params {:Identity ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Identity="

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}}/v2/Services/:ServiceSid/Entities"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Identity", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Identity=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities"

	payload := strings.NewReader("Identity=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/Entities HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 9

Identity=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Identity="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Identity=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/Entities")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Identity=")
  .asString();

const data = 'Identity=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Identity', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Identity: ''})
};

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}}/v2/Services/:ServiceSid/Entities',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Identity: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Identity=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({Identity: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Identity: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities');

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

req.form({
  Identity: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Identity', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Identity', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Identity=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Identity=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities', [
  'form_params' => [
    'Identity' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Identity' => ''
]);

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

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

append(new http\QueryString([
  'Identity' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Identity='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Identity='

import http.client

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

payload = "Identity="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/Entities", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities"

payload <- "Identity="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities")

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

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

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

require 'faraday'

data = {
  :Identity => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/Entities') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/Entities \
  content-type:application/x-www-form-urlencoded \
  Identity=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Identity= \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities

import Foundation

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

let postData = NSMutableData(data: "Identity=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities")! 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}}/v2/Services/:ServiceSid/MessagingConfigurations");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Country=&MessagingServiceSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations" {:form-params {:Country ""
                                                                                                          :MessagingServiceSid ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Country=&MessagingServiceSid="

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}}/v2/Services/:ServiceSid/MessagingConfigurations"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Country", "" },
        { "MessagingServiceSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Country=&MessagingServiceSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"

	payload := strings.NewReader("Country=&MessagingServiceSid=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/MessagingConfigurations HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 29

Country=&MessagingServiceSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Country=&MessagingServiceSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Country=&MessagingServiceSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Country=&MessagingServiceSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Country=&MessagingServiceSid=")
  .asString();

const data = 'Country=&MessagingServiceSid=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Country', '');
encodedParams.set('MessagingServiceSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Country: '', MessagingServiceSid: ''})
};

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}}/v2/Services/:ServiceSid/MessagingConfigurations',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Country: '',
    MessagingServiceSid: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Country=&MessagingServiceSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({Country: '', MessagingServiceSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Country: '', MessagingServiceSid: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations');

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

req.form({
  Country: '',
  MessagingServiceSid: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Country', '');
encodedParams.set('MessagingServiceSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Country', '');
encodedParams.set('MessagingServiceSid', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"]
                                                       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}}/v2/Services/:ServiceSid/MessagingConfigurations" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Country=&MessagingServiceSid=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Country=&MessagingServiceSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations', [
  'form_params' => [
    'Country' => '',
    'MessagingServiceSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Country' => '',
  'MessagingServiceSid' => ''
]);

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

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

append(new http\QueryString([
  'Country' => '',
  'MessagingServiceSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Country=&MessagingServiceSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Country=&MessagingServiceSid='

import http.client

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

payload = "Country=&MessagingServiceSid="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"

payload <- "Country=&MessagingServiceSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")

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

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

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

require 'faraday'

data = {
  :Country => "",
  :MessagingServiceSid => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Country": "",
        "MessagingServiceSid": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations \
  content-type:application/x-www-form-urlencoded \
  Country='' \
  MessagingServiceSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Country=&MessagingServiceSid=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations

import Foundation

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

let postData = NSMutableData(data: "Country=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingServiceSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")! 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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors" {:form-params {:Binding.Alg ""
                                                                                                             :Binding.PublicKey ""
                                                                                                             :Binding.Secret ""
                                                                                                             :Config.Alg ""
                                                                                                             :Config.AppId ""
                                                                                                             :Config.CodeLength ""
                                                                                                             :Config.NotificationPlatform ""
                                                                                                             :Config.NotificationToken ""
                                                                                                             :Config.SdkVersion ""
                                                                                                             :Config.Skew ""
                                                                                                             :Config.TimeStep ""
                                                                                                             :FactorType ""
                                                                                                             :FriendlyName ""
                                                                                                             :Metadata ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata="

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Binding.Alg", "" },
        { "Binding.PublicKey", "" },
        { "Binding.Secret", "" },
        { "Config.Alg", "" },
        { "Config.AppId", "" },
        { "Config.CodeLength", "" },
        { "Config.NotificationPlatform", "" },
        { "Config.NotificationToken", "" },
        { "Config.SdkVersion", "" },
        { "Config.Skew", "" },
        { "Config.TimeStep", "" },
        { "FactorType", "" },
        { "FriendlyName", "" },
        { "Metadata", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"

	payload := strings.NewReader("Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 232

Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=")
  .asString();

const data = 'Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Binding.Alg', '');
encodedParams.set('Binding.PublicKey', '');
encodedParams.set('Binding.Secret', '');
encodedParams.set('Config.Alg', '');
encodedParams.set('Config.AppId', '');
encodedParams.set('Config.CodeLength', '');
encodedParams.set('Config.NotificationPlatform', '');
encodedParams.set('Config.NotificationToken', '');
encodedParams.set('Config.SdkVersion', '');
encodedParams.set('Config.Skew', '');
encodedParams.set('Config.TimeStep', '');
encodedParams.set('FactorType', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Metadata', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    'Binding.Alg': '',
    'Binding.PublicKey': '',
    'Binding.Secret': '',
    'Config.Alg': '',
    'Config.AppId': '',
    'Config.CodeLength': '',
    'Config.NotificationPlatform': '',
    'Config.NotificationToken': '',
    'Config.SdkVersion': '',
    'Config.Skew': '',
    'Config.TimeStep': '',
    FactorType: '',
    FriendlyName: '',
    Metadata: ''
  })
};

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    'Binding.Alg': '',
    'Binding.PublicKey': '',
    'Binding.Secret': '',
    'Config.Alg': '',
    'Config.AppId': '',
    'Config.CodeLength': '',
    'Config.NotificationPlatform': '',
    'Config.NotificationToken': '',
    'Config.SdkVersion': '',
    'Config.Skew': '',
    'Config.TimeStep': '',
    FactorType: '',
    FriendlyName: '',
    Metadata: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({
  'Binding.Alg': '',
  'Binding.PublicKey': '',
  'Binding.Secret': '',
  'Config.Alg': '',
  'Config.AppId': '',
  'Config.CodeLength': '',
  'Config.NotificationPlatform': '',
  'Config.NotificationToken': '',
  'Config.SdkVersion': '',
  'Config.Skew': '',
  'Config.TimeStep': '',
  FactorType: '',
  FriendlyName: '',
  Metadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    'Binding.Alg': '',
    'Binding.PublicKey': '',
    'Binding.Secret': '',
    'Config.Alg': '',
    'Config.AppId': '',
    'Config.CodeLength': '',
    'Config.NotificationPlatform': '',
    'Config.NotificationToken': '',
    'Config.SdkVersion': '',
    'Config.Skew': '',
    'Config.TimeStep': '',
    FactorType: '',
    FriendlyName: '',
    Metadata: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors');

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

req.form({
  'Binding.Alg': '',
  'Binding.PublicKey': '',
  'Binding.Secret': '',
  'Config.Alg': '',
  'Config.AppId': '',
  'Config.CodeLength': '',
  'Config.NotificationPlatform': '',
  'Config.NotificationToken': '',
  'Config.SdkVersion': '',
  'Config.Skew': '',
  'Config.TimeStep': '',
  FactorType: '',
  FriendlyName: '',
  Metadata: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Binding.Alg', '');
encodedParams.set('Binding.PublicKey', '');
encodedParams.set('Binding.Secret', '');
encodedParams.set('Config.Alg', '');
encodedParams.set('Config.AppId', '');
encodedParams.set('Config.CodeLength', '');
encodedParams.set('Config.NotificationPlatform', '');
encodedParams.set('Config.NotificationToken', '');
encodedParams.set('Config.SdkVersion', '');
encodedParams.set('Config.Skew', '');
encodedParams.set('Config.TimeStep', '');
encodedParams.set('FactorType', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Metadata', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Binding.Alg', '');
encodedParams.set('Binding.PublicKey', '');
encodedParams.set('Binding.Secret', '');
encodedParams.set('Config.Alg', '');
encodedParams.set('Config.AppId', '');
encodedParams.set('Config.CodeLength', '');
encodedParams.set('Config.NotificationPlatform', '');
encodedParams.set('Config.NotificationToken', '');
encodedParams.set('Config.SdkVersion', '');
encodedParams.set('Config.Skew', '');
encodedParams.set('Config.TimeStep', '');
encodedParams.set('FactorType', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Metadata', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Binding.Alg=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Binding.PublicKey=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Binding.Secret=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.Alg=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.AppId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.CodeLength=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.NotificationPlatform=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.NotificationToken=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.SdkVersion=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.Skew=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.TimeStep=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FactorType=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Metadata=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors', [
  'form_params' => [
    'Binding.Alg' => '',
    'Binding.PublicKey' => '',
    'Binding.Secret' => '',
    'Config.Alg' => '',
    'Config.AppId' => '',
    'Config.CodeLength' => '',
    'Config.NotificationPlatform' => '',
    'Config.NotificationToken' => '',
    'Config.SdkVersion' => '',
    'Config.Skew' => '',
    'Config.TimeStep' => '',
    'FactorType' => '',
    'FriendlyName' => '',
    'Metadata' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Binding.Alg' => '',
  'Binding.PublicKey' => '',
  'Binding.Secret' => '',
  'Config.Alg' => '',
  'Config.AppId' => '',
  'Config.CodeLength' => '',
  'Config.NotificationPlatform' => '',
  'Config.NotificationToken' => '',
  'Config.SdkVersion' => '',
  'Config.Skew' => '',
  'Config.TimeStep' => '',
  'FactorType' => '',
  'FriendlyName' => '',
  'Metadata' => ''
]);

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

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

append(new http\QueryString([
  'Binding.Alg' => '',
  'Binding.PublicKey' => '',
  'Binding.Secret' => '',
  'Config.Alg' => '',
  'Config.AppId' => '',
  'Config.CodeLength' => '',
  'Config.NotificationPlatform' => '',
  'Config.NotificationToken' => '',
  'Config.SdkVersion' => '',
  'Config.Skew' => '',
  'Config.TimeStep' => '',
  'FactorType' => '',
  'FriendlyName' => '',
  'Metadata' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata='

import http.client

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

payload = "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"

payload = {
    "Binding.Alg": "",
    "Binding.PublicKey": "",
    "Binding.Secret": "",
    "Config.Alg": "",
    "Config.AppId": "",
    "Config.CodeLength": "",
    "Config.NotificationPlatform": "",
    "Config.NotificationToken": "",
    "Config.SdkVersion": "",
    "Config.Skew": "",
    "Config.TimeStep": "",
    "FactorType": "",
    "FriendlyName": "",
    "Metadata": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"

payload <- "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata="

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

require 'faraday'

data = {
  :Binding.Alg => "",
  :Binding.PublicKey => "",
  :Binding.Secret => "",
  :Config.Alg => "",
  :Config.AppId => "",
  :Config.CodeLength => "",
  :Config.NotificationPlatform => "",
  :Config.NotificationToken => "",
  :Config.SdkVersion => "",
  :Config.Skew => "",
  :Config.TimeStep => "",
  :FactorType => "",
  :FriendlyName => "",
  :Metadata => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors";

    let payload = json!({
        "Binding.Alg": "",
        "Binding.PublicKey": "",
        "Binding.Secret": "",
        "Config.Alg": "",
        "Config.AppId": "",
        "Config.CodeLength": "",
        "Config.NotificationPlatform": "",
        "Config.NotificationToken": "",
        "Config.SdkVersion": "",
        "Config.Skew": "",
        "Config.TimeStep": "",
        "FactorType": "",
        "FriendlyName": "",
        "Metadata": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors \
  content-type:application/x-www-form-urlencoded \
  Binding.Alg='' \
  Binding.PublicKey='' \
  Binding.Secret='' \
  Config.Alg='' \
  Config.AppId='' \
  Config.CodeLength='' \
  Config.NotificationPlatform='' \
  Config.NotificationToken='' \
  Config.SdkVersion='' \
  Config.Skew='' \
  Config.TimeStep='' \
  FactorType='' \
  FriendlyName='' \
  Metadata=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Binding.Alg=&Binding.PublicKey=&Binding.Secret=&Config.Alg=&Config.AppId=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FactorType=&FriendlyName=&Metadata=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors

import Foundation

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

let postData = NSMutableData(data: "Binding.Alg=".data(using: String.Encoding.utf8)!)
postData.append("&Binding.PublicKey=".data(using: String.Encoding.utf8)!)
postData.append("&Binding.Secret=".data(using: String.Encoding.utf8)!)
postData.append("&Config.Alg=".data(using: String.Encoding.utf8)!)
postData.append("&Config.AppId=".data(using: String.Encoding.utf8)!)
postData.append("&Config.CodeLength=".data(using: String.Encoding.utf8)!)
postData.append("&Config.NotificationPlatform=".data(using: String.Encoding.utf8)!)
postData.append("&Config.NotificationToken=".data(using: String.Encoding.utf8)!)
postData.append("&Config.SdkVersion=".data(using: String.Encoding.utf8)!)
postData.append("&Config.Skew=".data(using: String.Encoding.utf8)!)
postData.append("&Config.TimeStep=".data(using: String.Encoding.utf8)!)
postData.append("&FactorType=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Metadata=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")! 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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Ttl=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications" {:form-params {:Ttl ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Ttl="

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Ttl", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Ttl=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications"

	payload := strings.NewReader("Ttl=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 4

Ttl=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Ttl=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Ttl="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Ttl=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Ttl=")
  .asString();

const data = 'Ttl=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Ttl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Ttl: ''})
};

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Ttl: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Ttl=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

req.write(qs.stringify({Ttl: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Ttl: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications');

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

req.form({
  Ttl: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Ttl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Ttl', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Ttl=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Ttl=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Ttl=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications', [
  'form_params' => [
    'Ttl' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Ttl' => ''
]);

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

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

append(new http\QueryString([
  'Ttl' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Ttl='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Ttl='

import http.client

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

payload = "Ttl="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications"

payload <- "Ttl="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications")

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

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

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

require 'faraday'

data = {
  :Ttl => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications";

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

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications \
  content-type:application/x-www-form-urlencoded \
  Ttl=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Ttl= \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications

import Foundation

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

let postData = NSMutableData(data: "Ttl=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:ChallengeSid/Notifications")! 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}}/v2/Services/:ServiceSid/RateLimits");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Description=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits" {:form-params {:Description ""
                                                                                             :UniqueName ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Description=&UniqueName="

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}}/v2/Services/:ServiceSid/RateLimits"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Description", "" },
        { "UniqueName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Description=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"

	payload := strings.NewReader("Description=&UniqueName=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/RateLimits HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 24

Description=&UniqueName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Description=&UniqueName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Description=&UniqueName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Description=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Description=&UniqueName=")
  .asString();

const data = 'Description=&UniqueName=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Description', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Description: '', UniqueName: ''})
};

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}}/v2/Services/:ServiceSid/RateLimits',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Description: '',
    UniqueName: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Description=&UniqueName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({Description: '', UniqueName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Description: '', UniqueName: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits');

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

req.form({
  Description: '',
  UniqueName: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Description', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Description', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Description=&UniqueName=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Description=&UniqueName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits', [
  'form_params' => [
    'Description' => '',
    'UniqueName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Description' => '',
  'UniqueName' => ''
]);

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

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

append(new http\QueryString([
  'Description' => '',
  'UniqueName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Description=&UniqueName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Description=&UniqueName='

import http.client

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

payload = "Description=&UniqueName="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/RateLimits", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"

payload <- "Description=&UniqueName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")

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

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

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

require 'faraday'

data = {
  :Description => "",
  :UniqueName => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/RateLimits') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Description": "",
        "UniqueName": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/RateLimits \
  content-type:application/x-www-form-urlencoded \
  Description='' \
  UniqueName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Description=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits

import Foundation

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

let postData = NSMutableData(data: "Description=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")! 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}}/v2/SafeList/Numbers");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "PhoneNumber=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/SafeList/Numbers" {:form-params {:PhoneNumber ""}})

require "http/client"

url = "{{baseUrl}}/v2/SafeList/Numbers"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "PhoneNumber="

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}}/v2/SafeList/Numbers"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "PhoneNumber", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/SafeList/Numbers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "PhoneNumber=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/SafeList/Numbers"

	payload := strings.NewReader("PhoneNumber=")

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

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

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

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

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

}

POST /baseUrl/v2/SafeList/Numbers HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 12

PhoneNumber=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/SafeList/Numbers"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("PhoneNumber="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "PhoneNumber=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/SafeList/Numbers")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/SafeList/Numbers")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("PhoneNumber=")
  .asString();

const data = 'PhoneNumber=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/SafeList/Numbers');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('PhoneNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/SafeList/Numbers',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/SafeList/Numbers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({PhoneNumber: ''})
};

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "PhoneNumber=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/SafeList/Numbers")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({PhoneNumber: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/SafeList/Numbers');

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

req.form({
  PhoneNumber: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('PhoneNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/SafeList/Numbers',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('PhoneNumber', '');

const url = '{{baseUrl}}/v2/SafeList/Numbers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"PhoneNumber=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/SafeList/Numbers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/SafeList/Numbers" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "PhoneNumber=" in

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

 "{{baseUrl}}/v2/SafeList/Numbers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "PhoneNumber=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/SafeList/Numbers', [
  'form_params' => [
    'PhoneNumber' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/SafeList/Numbers');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'PhoneNumber' => ''
]);

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

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

append(new http\QueryString([
  'PhoneNumber' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/SafeList/Numbers');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/SafeList/Numbers' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'PhoneNumber='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/SafeList/Numbers' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'PhoneNumber='

import http.client

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

payload = "PhoneNumber="

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

conn.request("POST", "/baseUrl/v2/SafeList/Numbers", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/SafeList/Numbers"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/SafeList/Numbers"

payload <- "PhoneNumber="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/SafeList/Numbers")

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

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

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

require 'faraday'

data = {
  :PhoneNumber => "",
}

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

response = conn.post('/baseUrl/v2/SafeList/Numbers') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/SafeList/Numbers \
  content-type:application/x-www-form-urlencoded \
  PhoneNumber=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data PhoneNumber= \
  --output-document \
  - {{baseUrl}}/v2/SafeList/Numbers

import Foundation

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

let postData = NSMutableData(data: "PhoneNumber=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services" {:form-params {:CodeLength ""
                                                                      :CustomCodeEnabled ""
                                                                      :DefaultTemplateSid ""
                                                                      :DoNotShareWarningEnabled ""
                                                                      :DtmfInputRequired ""
                                                                      :FriendlyName ""
                                                                      :LookupEnabled ""
                                                                      :Psd2Enabled ""
                                                                      :Push.ApnCredentialSid ""
                                                                      :Push.FcmCredentialSid ""
                                                                      :Push.IncludeDate ""
                                                                      :SkipSmsToLandlines ""
                                                                      :Totp.CodeLength ""
                                                                      :Totp.Issuer ""
                                                                      :Totp.Skew ""
                                                                      :Totp.TimeStep ""
                                                                      :TtsName ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="

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}}/v2/Services"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "CodeLength", "" },
        { "CustomCodeEnabled", "" },
        { "DefaultTemplateSid", "" },
        { "DoNotShareWarningEnabled", "" },
        { "DtmfInputRequired", "" },
        { "FriendlyName", "" },
        { "LookupEnabled", "" },
        { "Psd2Enabled", "" },
        { "Push.ApnCredentialSid", "" },
        { "Push.FcmCredentialSid", "" },
        { "Push.IncludeDate", "" },
        { "SkipSmsToLandlines", "" },
        { "Totp.CodeLength", "" },
        { "Totp.Issuer", "" },
        { "Totp.Skew", "" },
        { "Totp.TimeStep", "" },
        { "TtsName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services"

	payload := strings.NewReader("CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=")

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

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

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

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

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

}

POST /baseUrl/v2/Services HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 286

CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=")
  .asString();

const data = 'CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('CodeLength', '');
encodedParams.set('CustomCodeEnabled', '');
encodedParams.set('DefaultTemplateSid', '');
encodedParams.set('DoNotShareWarningEnabled', '');
encodedParams.set('DtmfInputRequired', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('LookupEnabled', '');
encodedParams.set('Psd2Enabled', '');
encodedParams.set('Push.ApnCredentialSid', '');
encodedParams.set('Push.FcmCredentialSid', '');
encodedParams.set('Push.IncludeDate', '');
encodedParams.set('SkipSmsToLandlines', '');
encodedParams.set('Totp.CodeLength', '');
encodedParams.set('Totp.Issuer', '');
encodedParams.set('Totp.Skew', '');
encodedParams.set('Totp.TimeStep', '');
encodedParams.set('TtsName', '');

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

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

const url = '{{baseUrl}}/v2/Services';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    CodeLength: '',
    CustomCodeEnabled: '',
    DefaultTemplateSid: '',
    DoNotShareWarningEnabled: '',
    DtmfInputRequired: '',
    FriendlyName: '',
    LookupEnabled: '',
    Psd2Enabled: '',
    'Push.ApnCredentialSid': '',
    'Push.FcmCredentialSid': '',
    'Push.IncludeDate': '',
    SkipSmsToLandlines: '',
    'Totp.CodeLength': '',
    'Totp.Issuer': '',
    'Totp.Skew': '',
    'Totp.TimeStep': '',
    TtsName: ''
  })
};

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}}/v2/Services',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    CodeLength: '',
    CustomCodeEnabled: '',
    DefaultTemplateSid: '',
    DoNotShareWarningEnabled: '',
    DtmfInputRequired: '',
    FriendlyName: '',
    LookupEnabled: '',
    Psd2Enabled: '',
    'Push.ApnCredentialSid': '',
    'Push.FcmCredentialSid': '',
    'Push.IncludeDate': '',
    SkipSmsToLandlines: '',
    'Totp.CodeLength': '',
    'Totp.Issuer': '',
    'Totp.Skew': '',
    'Totp.TimeStep': '',
    TtsName: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({
  CodeLength: '',
  CustomCodeEnabled: '',
  DefaultTemplateSid: '',
  DoNotShareWarningEnabled: '',
  DtmfInputRequired: '',
  FriendlyName: '',
  LookupEnabled: '',
  Psd2Enabled: '',
  'Push.ApnCredentialSid': '',
  'Push.FcmCredentialSid': '',
  'Push.IncludeDate': '',
  SkipSmsToLandlines: '',
  'Totp.CodeLength': '',
  'Totp.Issuer': '',
  'Totp.Skew': '',
  'Totp.TimeStep': '',
  TtsName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    CodeLength: '',
    CustomCodeEnabled: '',
    DefaultTemplateSid: '',
    DoNotShareWarningEnabled: '',
    DtmfInputRequired: '',
    FriendlyName: '',
    LookupEnabled: '',
    Psd2Enabled: '',
    'Push.ApnCredentialSid': '',
    'Push.FcmCredentialSid': '',
    'Push.IncludeDate': '',
    SkipSmsToLandlines: '',
    'Totp.CodeLength': '',
    'Totp.Issuer': '',
    'Totp.Skew': '',
    'Totp.TimeStep': '',
    TtsName: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.form({
  CodeLength: '',
  CustomCodeEnabled: '',
  DefaultTemplateSid: '',
  DoNotShareWarningEnabled: '',
  DtmfInputRequired: '',
  FriendlyName: '',
  LookupEnabled: '',
  Psd2Enabled: '',
  'Push.ApnCredentialSid': '',
  'Push.FcmCredentialSid': '',
  'Push.IncludeDate': '',
  SkipSmsToLandlines: '',
  'Totp.CodeLength': '',
  'Totp.Issuer': '',
  'Totp.Skew': '',
  'Totp.TimeStep': '',
  TtsName: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('CodeLength', '');
encodedParams.set('CustomCodeEnabled', '');
encodedParams.set('DefaultTemplateSid', '');
encodedParams.set('DoNotShareWarningEnabled', '');
encodedParams.set('DtmfInputRequired', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('LookupEnabled', '');
encodedParams.set('Psd2Enabled', '');
encodedParams.set('Push.ApnCredentialSid', '');
encodedParams.set('Push.FcmCredentialSid', '');
encodedParams.set('Push.IncludeDate', '');
encodedParams.set('SkipSmsToLandlines', '');
encodedParams.set('Totp.CodeLength', '');
encodedParams.set('Totp.Issuer', '');
encodedParams.set('Totp.Skew', '');
encodedParams.set('Totp.TimeStep', '');
encodedParams.set('TtsName', '');

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

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('CodeLength', '');
encodedParams.set('CustomCodeEnabled', '');
encodedParams.set('DefaultTemplateSid', '');
encodedParams.set('DoNotShareWarningEnabled', '');
encodedParams.set('DtmfInputRequired', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('LookupEnabled', '');
encodedParams.set('Psd2Enabled', '');
encodedParams.set('Push.ApnCredentialSid', '');
encodedParams.set('Push.FcmCredentialSid', '');
encodedParams.set('Push.IncludeDate', '');
encodedParams.set('SkipSmsToLandlines', '');
encodedParams.set('Totp.CodeLength', '');
encodedParams.set('Totp.Issuer', '');
encodedParams.set('Totp.Skew', '');
encodedParams.set('Totp.TimeStep', '');
encodedParams.set('TtsName', '');

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

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"CodeLength=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CustomCodeEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultTemplateSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DoNotShareWarningEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DtmfInputRequired=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LookupEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Psd2Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Push.ApnCredentialSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Push.FcmCredentialSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Push.IncludeDate=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SkipSmsToLandlines=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Totp.CodeLength=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Totp.Issuer=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Totp.Skew=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Totp.TimeStep=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TtsName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services"]
                                                       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}}/v2/Services" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=" in

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

 "{{baseUrl}}/v2/Services",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services', [
  'form_params' => [
    'CodeLength' => '',
    'CustomCodeEnabled' => '',
    'DefaultTemplateSid' => '',
    'DoNotShareWarningEnabled' => '',
    'DtmfInputRequired' => '',
    'FriendlyName' => '',
    'LookupEnabled' => '',
    'Psd2Enabled' => '',
    'Push.ApnCredentialSid' => '',
    'Push.FcmCredentialSid' => '',
    'Push.IncludeDate' => '',
    'SkipSmsToLandlines' => '',
    'Totp.CodeLength' => '',
    'Totp.Issuer' => '',
    'Totp.Skew' => '',
    'Totp.TimeStep' => '',
    'TtsName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'CodeLength' => '',
  'CustomCodeEnabled' => '',
  'DefaultTemplateSid' => '',
  'DoNotShareWarningEnabled' => '',
  'DtmfInputRequired' => '',
  'FriendlyName' => '',
  'LookupEnabled' => '',
  'Psd2Enabled' => '',
  'Push.ApnCredentialSid' => '',
  'Push.FcmCredentialSid' => '',
  'Push.IncludeDate' => '',
  'SkipSmsToLandlines' => '',
  'Totp.CodeLength' => '',
  'Totp.Issuer' => '',
  'Totp.Skew' => '',
  'Totp.TimeStep' => '',
  'TtsName' => ''
]);

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

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

append(new http\QueryString([
  'CodeLength' => '',
  'CustomCodeEnabled' => '',
  'DefaultTemplateSid' => '',
  'DoNotShareWarningEnabled' => '',
  'DtmfInputRequired' => '',
  'FriendlyName' => '',
  'LookupEnabled' => '',
  'Psd2Enabled' => '',
  'Push.ApnCredentialSid' => '',
  'Push.FcmCredentialSid' => '',
  'Push.IncludeDate' => '',
  'SkipSmsToLandlines' => '',
  'Totp.CodeLength' => '',
  'Totp.Issuer' => '',
  'Totp.Skew' => '',
  'Totp.TimeStep' => '',
  'TtsName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName='

import http.client

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

payload = "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="

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

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

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

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

import requests

url = "{{baseUrl}}/v2/Services"

payload = {
    "CodeLength": "",
    "CustomCodeEnabled": "",
    "DefaultTemplateSid": "",
    "DoNotShareWarningEnabled": "",
    "DtmfInputRequired": "",
    "FriendlyName": "",
    "LookupEnabled": "",
    "Psd2Enabled": "",
    "Push.ApnCredentialSid": "",
    "Push.FcmCredentialSid": "",
    "Push.IncludeDate": "",
    "SkipSmsToLandlines": "",
    "Totp.CodeLength": "",
    "Totp.Issuer": "",
    "Totp.Skew": "",
    "Totp.TimeStep": "",
    "TtsName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services"

payload <- "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="

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

require 'faraday'

data = {
  :CodeLength => "",
  :CustomCodeEnabled => "",
  :DefaultTemplateSid => "",
  :DoNotShareWarningEnabled => "",
  :DtmfInputRequired => "",
  :FriendlyName => "",
  :LookupEnabled => "",
  :Psd2Enabled => "",
  :Push.ApnCredentialSid => "",
  :Push.FcmCredentialSid => "",
  :Push.IncludeDate => "",
  :SkipSmsToLandlines => "",
  :Totp.CodeLength => "",
  :Totp.Issuer => "",
  :Totp.Skew => "",
  :Totp.TimeStep => "",
  :TtsName => "",
}

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

response = conn.post('/baseUrl/v2/Services') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "CodeLength": "",
        "CustomCodeEnabled": "",
        "DefaultTemplateSid": "",
        "DoNotShareWarningEnabled": "",
        "DtmfInputRequired": "",
        "FriendlyName": "",
        "LookupEnabled": "",
        "Psd2Enabled": "",
        "Push.ApnCredentialSid": "",
        "Push.FcmCredentialSid": "",
        "Push.IncludeDate": "",
        "SkipSmsToLandlines": "",
        "Totp.CodeLength": "",
        "Totp.Issuer": "",
        "Totp.Skew": "",
        "Totp.TimeStep": "",
        "TtsName": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services \
  content-type:application/x-www-form-urlencoded \
  CodeLength='' \
  CustomCodeEnabled='' \
  DefaultTemplateSid='' \
  DoNotShareWarningEnabled='' \
  DtmfInputRequired='' \
  FriendlyName='' \
  LookupEnabled='' \
  Psd2Enabled='' \
  Push.ApnCredentialSid='' \
  Push.FcmCredentialSid='' \
  Push.IncludeDate='' \
  SkipSmsToLandlines='' \
  Totp.CodeLength='' \
  Totp.Issuer='' \
  Totp.Skew='' \
  Totp.TimeStep='' \
  TtsName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=' \
  --output-document \
  - {{baseUrl}}/v2/Services

import Foundation

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

let postData = NSMutableData(data: "CodeLength=".data(using: String.Encoding.utf8)!)
postData.append("&CustomCodeEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultTemplateSid=".data(using: String.Encoding.utf8)!)
postData.append("&DoNotShareWarningEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&DtmfInputRequired=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&LookupEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&Psd2Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Push.ApnCredentialSid=".data(using: String.Encoding.utf8)!)
postData.append("&Push.FcmCredentialSid=".data(using: String.Encoding.utf8)!)
postData.append("&Push.IncludeDate=".data(using: String.Encoding.utf8)!)
postData.append("&SkipSmsToLandlines=".data(using: String.Encoding.utf8)!)
postData.append("&Totp.CodeLength=".data(using: String.Encoding.utf8)!)
postData.append("&Totp.Issuer=".data(using: String.Encoding.utf8)!)
postData.append("&Totp.Skew=".data(using: String.Encoding.utf8)!)
postData.append("&Totp.TimeStep=".data(using: String.Encoding.utf8)!)
postData.append("&TtsName=".data(using: String.Encoding.utf8)!)

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/Verifications" {:form-params {:Amount ""
                                                                                                :AppHash ""
                                                                                                :Channel ""
                                                                                                :ChannelConfiguration ""
                                                                                                :CustomCode ""
                                                                                                :CustomFriendlyName ""
                                                                                                :CustomMessage ""
                                                                                                :DeviceIp ""
                                                                                                :Locale ""
                                                                                                :Payee ""
                                                                                                :RateLimits ""
                                                                                                :SendDigits ""
                                                                                                :TemplateCustomSubstitutions ""
                                                                                                :TemplateSid ""
                                                                                                :To ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Verifications"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To="

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}}/v2/Services/:ServiceSid/Verifications"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Amount", "" },
        { "AppHash", "" },
        { "Channel", "" },
        { "ChannelConfiguration", "" },
        { "CustomCode", "" },
        { "CustomFriendlyName", "" },
        { "CustomMessage", "" },
        { "DeviceIp", "" },
        { "Locale", "" },
        { "Payee", "" },
        { "RateLimits", "" },
        { "SendDigits", "" },
        { "TemplateCustomSubstitutions", "" },
        { "TemplateSid", "" },
        { "To", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Verifications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Verifications"

	payload := strings.NewReader("Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/Verifications HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 189

Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/Verifications")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Verifications"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Verifications")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/Verifications")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=")
  .asString();

const data = 'Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Verifications');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Amount', '');
encodedParams.set('AppHash', '');
encodedParams.set('Channel', '');
encodedParams.set('ChannelConfiguration', '');
encodedParams.set('CustomCode', '');
encodedParams.set('CustomFriendlyName', '');
encodedParams.set('CustomMessage', '');
encodedParams.set('DeviceIp', '');
encodedParams.set('Locale', '');
encodedParams.set('Payee', '');
encodedParams.set('RateLimits', '');
encodedParams.set('SendDigits', '');
encodedParams.set('TemplateCustomSubstitutions', '');
encodedParams.set('TemplateSid', '');
encodedParams.set('To', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Verifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Verifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Amount: '',
    AppHash: '',
    Channel: '',
    ChannelConfiguration: '',
    CustomCode: '',
    CustomFriendlyName: '',
    CustomMessage: '',
    DeviceIp: '',
    Locale: '',
    Payee: '',
    RateLimits: '',
    SendDigits: '',
    TemplateCustomSubstitutions: '',
    TemplateSid: '',
    To: ''
  })
};

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}}/v2/Services/:ServiceSid/Verifications',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Amount: '',
    AppHash: '',
    Channel: '',
    ChannelConfiguration: '',
    CustomCode: '',
    CustomFriendlyName: '',
    CustomMessage: '',
    DeviceIp: '',
    Locale: '',
    Payee: '',
    RateLimits: '',
    SendDigits: '',
    TemplateCustomSubstitutions: '',
    TemplateSid: '',
    To: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Verifications")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({
  Amount: '',
  AppHash: '',
  Channel: '',
  ChannelConfiguration: '',
  CustomCode: '',
  CustomFriendlyName: '',
  CustomMessage: '',
  DeviceIp: '',
  Locale: '',
  Payee: '',
  RateLimits: '',
  SendDigits: '',
  TemplateCustomSubstitutions: '',
  TemplateSid: '',
  To: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Verifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Amount: '',
    AppHash: '',
    Channel: '',
    ChannelConfiguration: '',
    CustomCode: '',
    CustomFriendlyName: '',
    CustomMessage: '',
    DeviceIp: '',
    Locale: '',
    Payee: '',
    RateLimits: '',
    SendDigits: '',
    TemplateCustomSubstitutions: '',
    TemplateSid: '',
    To: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Verifications');

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

req.form({
  Amount: '',
  AppHash: '',
  Channel: '',
  ChannelConfiguration: '',
  CustomCode: '',
  CustomFriendlyName: '',
  CustomMessage: '',
  DeviceIp: '',
  Locale: '',
  Payee: '',
  RateLimits: '',
  SendDigits: '',
  TemplateCustomSubstitutions: '',
  TemplateSid: '',
  To: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Amount', '');
encodedParams.set('AppHash', '');
encodedParams.set('Channel', '');
encodedParams.set('ChannelConfiguration', '');
encodedParams.set('CustomCode', '');
encodedParams.set('CustomFriendlyName', '');
encodedParams.set('CustomMessage', '');
encodedParams.set('DeviceIp', '');
encodedParams.set('Locale', '');
encodedParams.set('Payee', '');
encodedParams.set('RateLimits', '');
encodedParams.set('SendDigits', '');
encodedParams.set('TemplateCustomSubstitutions', '');
encodedParams.set('TemplateSid', '');
encodedParams.set('To', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Verifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Amount', '');
encodedParams.set('AppHash', '');
encodedParams.set('Channel', '');
encodedParams.set('ChannelConfiguration', '');
encodedParams.set('CustomCode', '');
encodedParams.set('CustomFriendlyName', '');
encodedParams.set('CustomMessage', '');
encodedParams.set('DeviceIp', '');
encodedParams.set('Locale', '');
encodedParams.set('Payee', '');
encodedParams.set('RateLimits', '');
encodedParams.set('SendDigits', '');
encodedParams.set('TemplateCustomSubstitutions', '');
encodedParams.set('TemplateSid', '');
encodedParams.set('To', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Verifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Amount=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AppHash=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Channel=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ChannelConfiguration=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CustomCode=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CustomFriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CustomMessage=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DeviceIp=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Locale=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Payee=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RateLimits=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SendDigits=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TemplateCustomSubstitutions=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TemplateSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&To=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/Verifications"]
                                                       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}}/v2/Services/:ServiceSid/Verifications" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/Verifications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Verifications', [
  'form_params' => [
    'Amount' => '',
    'AppHash' => '',
    'Channel' => '',
    'ChannelConfiguration' => '',
    'CustomCode' => '',
    'CustomFriendlyName' => '',
    'CustomMessage' => '',
    'DeviceIp' => '',
    'Locale' => '',
    'Payee' => '',
    'RateLimits' => '',
    'SendDigits' => '',
    'TemplateCustomSubstitutions' => '',
    'TemplateSid' => '',
    'To' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Verifications');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Amount' => '',
  'AppHash' => '',
  'Channel' => '',
  'ChannelConfiguration' => '',
  'CustomCode' => '',
  'CustomFriendlyName' => '',
  'CustomMessage' => '',
  'DeviceIp' => '',
  'Locale' => '',
  'Payee' => '',
  'RateLimits' => '',
  'SendDigits' => '',
  'TemplateCustomSubstitutions' => '',
  'TemplateSid' => '',
  'To' => ''
]);

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

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

append(new http\QueryString([
  'Amount' => '',
  'AppHash' => '',
  'Channel' => '',
  'ChannelConfiguration' => '',
  'CustomCode' => '',
  'CustomFriendlyName' => '',
  'CustomMessage' => '',
  'DeviceIp' => '',
  'Locale' => '',
  'Payee' => '',
  'RateLimits' => '',
  'SendDigits' => '',
  'TemplateCustomSubstitutions' => '',
  'TemplateSid' => '',
  'To' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Verifications');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Verifications' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Verifications' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To='

import http.client

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

payload = "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/Verifications", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Verifications"

payload = {
    "Amount": "",
    "AppHash": "",
    "Channel": "",
    "ChannelConfiguration": "",
    "CustomCode": "",
    "CustomFriendlyName": "",
    "CustomMessage": "",
    "DeviceIp": "",
    "Locale": "",
    "Payee": "",
    "RateLimits": "",
    "SendDigits": "",
    "TemplateCustomSubstitutions": "",
    "TemplateSid": "",
    "To": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Verifications"

payload <- "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Verifications")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To="

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

require 'faraday'

data = {
  :Amount => "",
  :AppHash => "",
  :Channel => "",
  :ChannelConfiguration => "",
  :CustomCode => "",
  :CustomFriendlyName => "",
  :CustomMessage => "",
  :DeviceIp => "",
  :Locale => "",
  :Payee => "",
  :RateLimits => "",
  :SendDigits => "",
  :TemplateCustomSubstitutions => "",
  :TemplateSid => "",
  :To => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/Verifications') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Amount": "",
        "AppHash": "",
        "Channel": "",
        "ChannelConfiguration": "",
        "CustomCode": "",
        "CustomFriendlyName": "",
        "CustomMessage": "",
        "DeviceIp": "",
        "Locale": "",
        "Payee": "",
        "RateLimits": "",
        "SendDigits": "",
        "TemplateCustomSubstitutions": "",
        "TemplateSid": "",
        "To": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/Verifications \
  content-type:application/x-www-form-urlencoded \
  Amount='' \
  AppHash='' \
  Channel='' \
  ChannelConfiguration='' \
  CustomCode='' \
  CustomFriendlyName='' \
  CustomMessage='' \
  DeviceIp='' \
  Locale='' \
  Payee='' \
  RateLimits='' \
  SendDigits='' \
  TemplateCustomSubstitutions='' \
  TemplateSid='' \
  To=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Amount=&AppHash=&Channel=&ChannelConfiguration=&CustomCode=&CustomFriendlyName=&CustomMessage=&DeviceIp=&Locale=&Payee=&RateLimits=&SendDigits=&TemplateCustomSubstitutions=&TemplateSid=&To=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Verifications

import Foundation

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

let postData = NSMutableData(data: "Amount=".data(using: String.Encoding.utf8)!)
postData.append("&AppHash=".data(using: String.Encoding.utf8)!)
postData.append("&Channel=".data(using: String.Encoding.utf8)!)
postData.append("&ChannelConfiguration=".data(using: String.Encoding.utf8)!)
postData.append("&CustomCode=".data(using: String.Encoding.utf8)!)
postData.append("&CustomFriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&CustomMessage=".data(using: String.Encoding.utf8)!)
postData.append("&DeviceIp=".data(using: String.Encoding.utf8)!)
postData.append("&Locale=".data(using: String.Encoding.utf8)!)
postData.append("&Payee=".data(using: String.Encoding.utf8)!)
postData.append("&RateLimits=".data(using: String.Encoding.utf8)!)
postData.append("&SendDigits=".data(using: String.Encoding.utf8)!)
postData.append("&TemplateCustomSubstitutions=".data(using: String.Encoding.utf8)!)
postData.append("&TemplateSid=".data(using: String.Encoding.utf8)!)
postData.append("&To=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Verifications")! 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}}/v2/Services/:ServiceSid/VerificationCheck");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Amount=&Code=&Payee=&To=&VerificationSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck" {:form-params {:Amount ""
                                                                                                    :Code ""
                                                                                                    :Payee ""
                                                                                                    :To ""
                                                                                                    :VerificationSid ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Amount=&Code=&Payee=&To=&VerificationSid="

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}}/v2/Services/:ServiceSid/VerificationCheck"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Amount", "" },
        { "Code", "" },
        { "Payee", "" },
        { "To", "" },
        { "VerificationSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Amount=&Code=&Payee=&To=&VerificationSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck"

	payload := strings.NewReader("Amount=&Code=&Payee=&To=&VerificationSid=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/VerificationCheck HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 41

Amount=&Code=&Payee=&To=&VerificationSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Amount=&Code=&Payee=&To=&VerificationSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Amount=&Code=&Payee=&To=&VerificationSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Amount=&Code=&Payee=&To=&VerificationSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Amount=&Code=&Payee=&To=&VerificationSid=")
  .asString();

const data = 'Amount=&Code=&Payee=&To=&VerificationSid=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Amount', '');
encodedParams.set('Code', '');
encodedParams.set('Payee', '');
encodedParams.set('To', '');
encodedParams.set('VerificationSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Amount: '', Code: '', Payee: '', To: '', VerificationSid: ''})
};

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}}/v2/Services/:ServiceSid/VerificationCheck',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Amount: '',
    Code: '',
    Payee: '',
    To: '',
    VerificationSid: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Amount=&Code=&Payee=&To=&VerificationSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({Amount: '', Code: '', Payee: '', To: '', VerificationSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Amount: '', Code: '', Payee: '', To: '', VerificationSid: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck');

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

req.form({
  Amount: '',
  Code: '',
  Payee: '',
  To: '',
  VerificationSid: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Amount', '');
encodedParams.set('Code', '');
encodedParams.set('Payee', '');
encodedParams.set('To', '');
encodedParams.set('VerificationSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Amount', '');
encodedParams.set('Code', '');
encodedParams.set('Payee', '');
encodedParams.set('To', '');
encodedParams.set('VerificationSid', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Amount=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Code=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Payee=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&To=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&VerificationSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck"]
                                                       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}}/v2/Services/:ServiceSid/VerificationCheck" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Amount=&Code=&Payee=&To=&VerificationSid=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Amount=&Code=&Payee=&To=&VerificationSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck', [
  'form_params' => [
    'Amount' => '',
    'Code' => '',
    'Payee' => '',
    'To' => '',
    'VerificationSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Amount' => '',
  'Code' => '',
  'Payee' => '',
  'To' => '',
  'VerificationSid' => ''
]);

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

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

append(new http\QueryString([
  'Amount' => '',
  'Code' => '',
  'Payee' => '',
  'To' => '',
  'VerificationSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Amount=&Code=&Payee=&To=&VerificationSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Amount=&Code=&Payee=&To=&VerificationSid='

import http.client

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

payload = "Amount=&Code=&Payee=&To=&VerificationSid="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/VerificationCheck", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck"

payload = {
    "Amount": "",
    "Code": "",
    "Payee": "",
    "To": "",
    "VerificationSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck"

payload <- "Amount=&Code=&Payee=&To=&VerificationSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Amount=&Code=&Payee=&To=&VerificationSid="

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

require 'faraday'

data = {
  :Amount => "",
  :Code => "",
  :Payee => "",
  :To => "",
  :VerificationSid => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/VerificationCheck') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Amount": "",
        "Code": "",
        "Payee": "",
        "To": "",
        "VerificationSid": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck \
  content-type:application/x-www-form-urlencoded \
  Amount='' \
  Code='' \
  Payee='' \
  To='' \
  VerificationSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Amount=&Code=&Payee=&To=&VerificationSid=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck

import Foundation

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

let postData = NSMutableData(data: "Amount=".data(using: String.Encoding.utf8)!)
postData.append("&Code=".data(using: String.Encoding.utf8)!)
postData.append("&Payee=".data(using: String.Encoding.utf8)!)
postData.append("&To=".data(using: String.Encoding.utf8)!)
postData.append("&VerificationSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/VerificationCheck")! 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}}/v2/Services/:ServiceSid/Webhooks");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks" {:form-params {:EventTypes ""
                                                                                           :FriendlyName ""
                                                                                           :Status ""
                                                                                           :Version ""
                                                                                           :WebhookUrl ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl="

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}}/v2/Services/:ServiceSid/Webhooks"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "EventTypes", "" },
        { "FriendlyName", "" },
        { "Status", "" },
        { "Version", "" },
        { "WebhookUrl", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"

	payload := strings.NewReader("EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=")

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

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

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

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

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

}

POST /baseUrl/v2/Services/:ServiceSid/Webhooks HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 54

EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=")
  .asString();

const data = 'EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=';

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

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

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('EventTypes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Status', '');
encodedParams.set('Version', '');
encodedParams.set('WebhookUrl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({EventTypes: '', FriendlyName: '', Status: '', Version: '', WebhookUrl: ''})
};

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}}/v2/Services/:ServiceSid/Webhooks',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    EventTypes: '',
    FriendlyName: '',
    Status: '',
    Version: '',
    WebhookUrl: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

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

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

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

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

req.write(qs.stringify({EventTypes: '', FriendlyName: '', Status: '', Version: '', WebhookUrl: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {EventTypes: '', FriendlyName: '', Status: '', Version: '', WebhookUrl: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks');

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

req.form({
  EventTypes: '',
  FriendlyName: '',
  Status: '',
  Version: '',
  WebhookUrl: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('EventTypes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Status', '');
encodedParams.set('Version', '');
encodedParams.set('WebhookUrl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('EventTypes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Status', '');
encodedParams.set('Version', '');
encodedParams.set('WebhookUrl', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"EventTypes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Status=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Version=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&WebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"]
                                                       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}}/v2/Services/:ServiceSid/Webhooks" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks', [
  'form_params' => [
    'EventTypes' => '',
    'FriendlyName' => '',
    'Status' => '',
    'Version' => '',
    'WebhookUrl' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Webhooks');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'EventTypes' => '',
  'FriendlyName' => '',
  'Status' => '',
  'Version' => '',
  'WebhookUrl' => ''
]);

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

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

append(new http\QueryString([
  'EventTypes' => '',
  'FriendlyName' => '',
  'Status' => '',
  'Version' => '',
  'WebhookUrl' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Webhooks');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl='

import http.client

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

payload = "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl="

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

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/Webhooks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"

payload = {
    "EventTypes": "",
    "FriendlyName": "",
    "Status": "",
    "Version": "",
    "WebhookUrl": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"

payload <- "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl="

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

require 'faraday'

data = {
  :EventTypes => "",
  :FriendlyName => "",
  :Status => "",
  :Version => "",
  :WebhookUrl => "",
}

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

response = conn.post('/baseUrl/v2/Services/:ServiceSid/Webhooks') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "EventTypes": "",
        "FriendlyName": "",
        "Status": "",
        "Version": "",
        "WebhookUrl": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/Webhooks \
  content-type:application/x-www-form-urlencoded \
  EventTypes='' \
  FriendlyName='' \
  Status='' \
  Version='' \
  WebhookUrl=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'EventTypes=&FriendlyName=&Status=&Version=&WebhookUrl=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Webhooks

import Foundation

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

let postData = NSMutableData(data: "EventTypes=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Status=".data(using: String.Encoding.utf8)!)
postData.append("&Version=".data(using: String.Encoding.utf8)!)
postData.append("&WebhookUrl=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")! 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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

	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/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"))
    .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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid'
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid';
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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid',
  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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid'
};

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

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid';
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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid",
  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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")

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/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid";

    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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity"

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

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity"

	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/v2/Services/:ServiceSid/Entities/:Identity HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")
  .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}}/v2/Services/:ServiceSid/Entities/:Identity');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity'
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity';
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}}/v2/Services/:ServiceSid/Entities/:Identity',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity');

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}}/v2/Services/:ServiceSid/Entities/:Identity'
};

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

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity';
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}}/v2/Services/:ServiceSid/Entities/:Identity"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity",
  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}}/v2/Services/:ServiceSid/Entities/:Identity');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity")

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")

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/v2/Services/:ServiceSid/Entities/:Identity') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity";

    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}}/v2/Services/:ServiceSid/Entities/:Identity

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

	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/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"))
    .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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid'
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid',
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid'
};

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

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid",
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")

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/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid";

    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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

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

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

	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/v2/Services/:ServiceSid/MessagingConfigurations/:Country HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country'
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country';
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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');

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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country'
};

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

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country';
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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"]
                                                       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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country",
  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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations/:Country")

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")

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/v2/Services/:ServiceSid/MessagingConfigurations/:Country') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country";

    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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

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

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

	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/v2/Services/:ServiceSid/RateLimits/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .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}}/v2/Services/:ServiceSid/RateLimits/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid'
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid';
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}}/v2/Services/:ServiceSid/RateLimits/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');

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}}/v2/Services/:ServiceSid/RateLimits/:Sid'
};

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

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid';
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}}/v2/Services/:ServiceSid/RateLimits/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits/:Sid" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid",
  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}}/v2/Services/:ServiceSid/RateLimits/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/Services/:ServiceSid/RateLimits/:Sid")

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")

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/v2/Services/:ServiceSid/RateLimits/:Sid') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid";

    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}}/v2/Services/:ServiceSid/RateLimits/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber")

require "http/client"

url = "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber"

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

var client = new RestClient("{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber"

	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/v2/SafeList/Numbers/:PhoneNumber HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber'
};

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

const url = '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber';
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}}/v2/SafeList/Numbers/:PhoneNumber',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber');

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}}/v2/SafeList/Numbers/:PhoneNumber'
};

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

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

const url = '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber';
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}}/v2/SafeList/Numbers/:PhoneNumber"]
                                                       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}}/v2/SafeList/Numbers/:PhoneNumber" in

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

 "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber",
  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}}/v2/SafeList/Numbers/:PhoneNumber');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/SafeList/Numbers/:PhoneNumber")

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

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

import requests

url = "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber")

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/v2/SafeList/Numbers/:PhoneNumber') do |req|
end

puts response.status
puts response.body

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

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

    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}}/v2/SafeList/Numbers/:PhoneNumber

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/Services/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/Services/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:Sid"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:Sid"

	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/v2/Services/:Sid HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/Services/:Sid'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/Services/:Sid');

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}}/v2/Services/:Sid'};

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

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

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

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

 "{{baseUrl}}/v2/Services/:Sid",
  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}}/v2/Services/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/Services/:Sid")

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

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

import requests

url = "{{baseUrl}}/v2/Services/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:Sid")

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/v2/Services/:Sid') do |req|
end

puts response.status
puts response.body

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

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

    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}}/v2/Services/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/Services/:Sid

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid"

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

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid"

	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/v2/Services/:ServiceSid/Webhooks/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")
  .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}}/v2/Services/:ServiceSid/Webhooks/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid'
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid';
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}}/v2/Services/:ServiceSid/Webhooks/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid');

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}}/v2/Services/:ServiceSid/Webhooks/:Sid'
};

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

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid';
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}}/v2/Services/:ServiceSid/Webhooks/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/Webhooks/:Sid" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid",
  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}}/v2/Services/:ServiceSid/Webhooks/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/Services/:ServiceSid/Webhooks/:Sid")

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

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

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")

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/v2/Services/:ServiceSid/Webhooks/:Sid') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid";

    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}}/v2/Services/:ServiceSid/Webhooks/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")! 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}}/v2/Services/:ServiceSid/AccessTokens/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid"

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

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid"

	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/v2/Services/:ServiceSid/AccessTokens/:Sid HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid"))
    .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}}/v2/Services/:ServiceSid/AccessTokens/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid")
  .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}}/v2/Services/:ServiceSid/AccessTokens/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid'
};

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid';
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}}/v2/Services/:ServiceSid/AccessTokens/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/AccessTokens/:Sid',
  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}}/v2/Services/:ServiceSid/AccessTokens/:Sid'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid');

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}}/v2/Services/:ServiceSid/AccessTokens/:Sid'
};

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

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

const url = '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid';
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}}/v2/Services/:ServiceSid/AccessTokens/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/AccessTokens/:Sid" in

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

 "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid",
  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}}/v2/Services/:ServiceSid/AccessTokens/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/AccessTokens/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid")

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/v2/Services/:ServiceSid/AccessTokens/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/AccessTokens/:Sid")! 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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

	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/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"))
    .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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid';
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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid',
  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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid';
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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid",
  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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")

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/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")! 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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"

	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/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"))
    .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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")
  .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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid',
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid');

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid",
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")

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/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")! 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}}/v2/Services/:ServiceSid/Entities/:Identity");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity"

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}}/v2/Services/:ServiceSid/Entities/:Identity"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity"

	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/v2/Services/:ServiceSid/Entities/:Identity HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity"))
    .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}}/v2/Services/:ServiceSid/Entities/:Identity")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")
  .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}}/v2/Services/:ServiceSid/Entities/:Identity');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity';
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}}/v2/Services/:ServiceSid/Entities/:Identity',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities/:Identity',
  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}}/v2/Services/:ServiceSid/Entities/:Identity'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity');

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}}/v2/Services/:ServiceSid/Entities/:Identity'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity';
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}}/v2/Services/:ServiceSid/Entities/:Identity"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity",
  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}}/v2/Services/:ServiceSid/Entities/:Identity');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")

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/v2/Services/:ServiceSid/Entities/:Identity') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity")! 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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

	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/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"))
    .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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid',
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid",
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")

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/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")! 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}}/v2/Forms/:FormType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Forms/:FormType")

require "http/client"

url = "{{baseUrl}}/v2/Forms/:FormType"

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}}/v2/Forms/:FormType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Forms/:FormType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Forms/:FormType"

	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/v2/Forms/:FormType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Forms/:FormType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Forms/:FormType"))
    .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}}/v2/Forms/:FormType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Forms/:FormType")
  .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}}/v2/Forms/:FormType');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/Forms/:FormType'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Forms/:FormType';
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}}/v2/Forms/:FormType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Forms/:FormType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Forms/:FormType',
  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}}/v2/Forms/:FormType'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Forms/:FormType');

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}}/v2/Forms/:FormType'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Forms/:FormType';
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}}/v2/Forms/:FormType"]
                                                       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}}/v2/Forms/:FormType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Forms/:FormType",
  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}}/v2/Forms/:FormType');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Forms/:FormType');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Forms/:FormType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Forms/:FormType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Forms/:FormType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Forms/:FormType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Forms/:FormType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Forms/:FormType"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Forms/:FormType")

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/v2/Forms/:FormType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Forms/:FormType";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Forms/:FormType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Forms/:FormType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Forms/:FormType")! 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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

	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/v2/Services/:ServiceSid/MessagingConfigurations/:Country HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"))
    .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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country';
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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations/:Country',
  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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');

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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country';
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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"]
                                                       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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country",
  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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations/:Country")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")

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/v2/Services/:ServiceSid/MessagingConfigurations/:Country') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")! 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}}/v2/Services/:ServiceSid/RateLimits/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

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}}/v2/Services/:ServiceSid/RateLimits/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

	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/v2/Services/:ServiceSid/RateLimits/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"))
    .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}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .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}}/v2/Services/:ServiceSid/RateLimits/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid';
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}}/v2/Services/:ServiceSid/RateLimits/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/RateLimits/:Sid',
  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}}/v2/Services/:ServiceSid/RateLimits/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');

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}}/v2/Services/:ServiceSid/RateLimits/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid';
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}}/v2/Services/:ServiceSid/RateLimits/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid",
  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}}/v2/Services/:ServiceSid/RateLimits/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/RateLimits/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")

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/v2/Services/:ServiceSid/RateLimits/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")! 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}}/v2/SafeList/Numbers/:PhoneNumber");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber")

require "http/client"

url = "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber"

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}}/v2/SafeList/Numbers/:PhoneNumber"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber"

	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/v2/SafeList/Numbers/:PhoneNumber HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber"))
    .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}}/v2/SafeList/Numbers/:PhoneNumber")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber")
  .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}}/v2/SafeList/Numbers/:PhoneNumber');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber';
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}}/v2/SafeList/Numbers/:PhoneNumber',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/SafeList/Numbers/:PhoneNumber',
  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}}/v2/SafeList/Numbers/:PhoneNumber'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber');

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}}/v2/SafeList/Numbers/:PhoneNumber'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber';
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}}/v2/SafeList/Numbers/:PhoneNumber"]
                                                       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}}/v2/SafeList/Numbers/:PhoneNumber" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber",
  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}}/v2/SafeList/Numbers/:PhoneNumber');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/SafeList/Numbers/:PhoneNumber")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber")

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/v2/SafeList/Numbers/:PhoneNumber') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/SafeList/Numbers/:PhoneNumber")! 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}}/v2/Services/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:Sid"

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}}/v2/Services/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:Sid"

	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/v2/Services/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:Sid"))
    .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}}/v2/Services/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:Sid")
  .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}}/v2/Services/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/Services/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:Sid';
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}}/v2/Services/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:Sid',
  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}}/v2/Services/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:Sid');

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}}/v2/Services/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:Sid';
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}}/v2/Services/:Sid"]
                                                       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}}/v2/Services/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:Sid",
  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}}/v2/Services/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:Sid")

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/v2/Services/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:Sid")! 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}}/v2/Services/:ServiceSid/Verifications/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"

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}}/v2/Services/:ServiceSid/Verifications/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"

	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/v2/Services/:ServiceSid/Verifications/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"))
    .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}}/v2/Services/:ServiceSid/Verifications/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")
  .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}}/v2/Services/:ServiceSid/Verifications/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid';
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}}/v2/Services/:ServiceSid/Verifications/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Verifications/:Sid',
  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}}/v2/Services/:ServiceSid/Verifications/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid');

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}}/v2/Services/:ServiceSid/Verifications/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid';
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}}/v2/Services/:ServiceSid/Verifications/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/Verifications/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid",
  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}}/v2/Services/:ServiceSid/Verifications/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/Verifications/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")

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/v2/Services/:ServiceSid/Verifications/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")! 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}}/v2/Attempts/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Attempts/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Attempts/:Sid"

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}}/v2/Attempts/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Attempts/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Attempts/:Sid"

	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/v2/Attempts/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Attempts/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Attempts/:Sid"))
    .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}}/v2/Attempts/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Attempts/:Sid")
  .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}}/v2/Attempts/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/Attempts/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Attempts/:Sid';
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}}/v2/Attempts/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Attempts/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Attempts/:Sid',
  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}}/v2/Attempts/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Attempts/:Sid');

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}}/v2/Attempts/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Attempts/:Sid';
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}}/v2/Attempts/:Sid"]
                                                       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}}/v2/Attempts/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Attempts/:Sid",
  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}}/v2/Attempts/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Attempts/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Attempts/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Attempts/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Attempts/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Attempts/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Attempts/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Attempts/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Attempts/:Sid")

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/v2/Attempts/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Attempts/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Attempts/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Attempts/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Attempts/:Sid")! 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}}/v2/Attempts/Summary");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Attempts/Summary")

require "http/client"

url = "{{baseUrl}}/v2/Attempts/Summary"

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}}/v2/Attempts/Summary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Attempts/Summary");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Attempts/Summary"

	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/v2/Attempts/Summary HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Attempts/Summary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Attempts/Summary"))
    .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}}/v2/Attempts/Summary")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Attempts/Summary")
  .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}}/v2/Attempts/Summary');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/Attempts/Summary'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Attempts/Summary';
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}}/v2/Attempts/Summary',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Attempts/Summary")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Attempts/Summary',
  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}}/v2/Attempts/Summary'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Attempts/Summary');

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}}/v2/Attempts/Summary'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Attempts/Summary';
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}}/v2/Attempts/Summary"]
                                                       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}}/v2/Attempts/Summary" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Attempts/Summary",
  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}}/v2/Attempts/Summary');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Attempts/Summary');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Attempts/Summary');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Attempts/Summary' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Attempts/Summary' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Attempts/Summary")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Attempts/Summary"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Attempts/Summary"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Attempts/Summary")

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/v2/Attempts/Summary') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Attempts/Summary";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Attempts/Summary

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Attempts/Summary

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Attempts/Summary")! 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}}/v2/Services/:ServiceSid/Webhooks/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid"

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}}/v2/Services/:ServiceSid/Webhooks/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid"

	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/v2/Services/:ServiceSid/Webhooks/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid"))
    .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}}/v2/Services/:ServiceSid/Webhooks/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")
  .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}}/v2/Services/:ServiceSid/Webhooks/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid';
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}}/v2/Services/:ServiceSid/Webhooks/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Webhooks/:Sid',
  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}}/v2/Services/:ServiceSid/Webhooks/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid');

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}}/v2/Services/:ServiceSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid';
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}}/v2/Services/:ServiceSid/Webhooks/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/Webhooks/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid",
  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}}/v2/Services/:ServiceSid/Webhooks/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/Webhooks/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")

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/v2/Services/:ServiceSid/Webhooks/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks/:Sid")! 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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"

	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/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"))
    .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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")
  .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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets';
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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets',
  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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets');

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets';
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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets",
  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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")

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/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets")! 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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"

	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/v2/Services/:ServiceSid/Entities/:Identity/Challenges HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"))
    .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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")
  .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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges',
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges');

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges",
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")

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/v2/Services/:ServiceSid/Entities/:Identity/Challenges') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges")! 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}}/v2/Services/:ServiceSid/Entities");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/Entities")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities"

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}}/v2/Services/:ServiceSid/Entities"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities"

	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/v2/Services/:ServiceSid/Entities HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/Entities")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities"))
    .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}}/v2/Services/:ServiceSid/Entities")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/Entities")
  .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}}/v2/Services/:ServiceSid/Entities');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities';
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}}/v2/Services/:ServiceSid/Entities',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities',
  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}}/v2/Services/:ServiceSid/Entities'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/Entities');

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}}/v2/Services/:ServiceSid/Entities'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities';
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}}/v2/Services/:ServiceSid/Entities"]
                                                       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}}/v2/Services/:ServiceSid/Entities" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities",
  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}}/v2/Services/:ServiceSid/Entities');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/Entities")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities")

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/v2/Services/:ServiceSid/Entities') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/Entities

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities")! 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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"

	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/v2/Services/:ServiceSid/Entities/:Identity/Factors HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"))
    .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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")
  .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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors',
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors');

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors';
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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors",
  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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")

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/v2/Services/:ServiceSid/Entities/:Identity/Factors') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors")! 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}}/v2/Services/:ServiceSid/MessagingConfigurations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"

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}}/v2/Services/:ServiceSid/MessagingConfigurations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"

	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/v2/Services/:ServiceSid/MessagingConfigurations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"))
    .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}}/v2/Services/:ServiceSid/MessagingConfigurations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")
  .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}}/v2/Services/:ServiceSid/MessagingConfigurations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations';
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}}/v2/Services/:ServiceSid/MessagingConfigurations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations',
  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}}/v2/Services/:ServiceSid/MessagingConfigurations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations');

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}}/v2/Services/:ServiceSid/MessagingConfigurations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations';
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}}/v2/Services/:ServiceSid/MessagingConfigurations"]
                                                       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}}/v2/Services/:ServiceSid/MessagingConfigurations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations",
  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}}/v2/Services/:ServiceSid/MessagingConfigurations');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")

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/v2/Services/:ServiceSid/MessagingConfigurations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations")! 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}}/v2/Services/:ServiceSid/RateLimits");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"

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}}/v2/Services/:ServiceSid/RateLimits"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"

	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/v2/Services/:ServiceSid/RateLimits HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"))
    .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}}/v2/Services/:ServiceSid/RateLimits")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")
  .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}}/v2/Services/:ServiceSid/RateLimits');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits';
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}}/v2/Services/:ServiceSid/RateLimits',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/RateLimits',
  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}}/v2/Services/:ServiceSid/RateLimits'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits');

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}}/v2/Services/:ServiceSid/RateLimits'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits';
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}}/v2/Services/:ServiceSid/RateLimits"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits",
  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}}/v2/Services/:ServiceSid/RateLimits');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/RateLimits")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")

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/v2/Services/:ServiceSid/RateLimits') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/RateLimits

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits")! 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}}/v2/Services");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services")

require "http/client"

url = "{{baseUrl}}/v2/Services"

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}}/v2/Services"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services"

	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/v2/Services HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services"))
    .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}}/v2/Services")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services")
  .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}}/v2/Services');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/Services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services';
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}}/v2/Services',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services',
  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}}/v2/Services'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services');

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}}/v2/Services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services';
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}}/v2/Services"]
                                                       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}}/v2/Services" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services",
  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}}/v2/Services');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services")

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/v2/Services') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services")! 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}}/v2/Attempts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Attempts")

require "http/client"

url = "{{baseUrl}}/v2/Attempts"

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}}/v2/Attempts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Attempts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Attempts"

	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/v2/Attempts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Attempts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Attempts"))
    .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}}/v2/Attempts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Attempts")
  .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}}/v2/Attempts');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/Attempts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Attempts';
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}}/v2/Attempts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Attempts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Attempts',
  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}}/v2/Attempts'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Attempts');

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}}/v2/Attempts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Attempts';
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}}/v2/Attempts"]
                                                       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}}/v2/Attempts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Attempts",
  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}}/v2/Attempts');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Attempts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Attempts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Attempts' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Attempts' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Attempts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Attempts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Attempts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Attempts")

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/v2/Attempts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Attempts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Attempts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Attempts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Attempts")! 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}}/v2/Templates");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Templates")

require "http/client"

url = "{{baseUrl}}/v2/Templates"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/Templates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Templates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Templates"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/Templates HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Templates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Templates"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Templates")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Templates")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/Templates');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/Templates'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Templates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/Templates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Templates")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Templates',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/Templates'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Templates');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v2/Templates'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Templates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Templates"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/Templates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Templates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/Templates');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Templates');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Templates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Templates' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Templates' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Templates")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Templates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Templates"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Templates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/Templates') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Templates";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Templates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Templates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Templates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"

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}}/v2/Services/:ServiceSid/Webhooks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"

	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/v2/Services/:ServiceSid/Webhooks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"))
    .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}}/v2/Services/:ServiceSid/Webhooks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")
  .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}}/v2/Services/:ServiceSid/Webhooks');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks';
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}}/v2/Services/:ServiceSid/Webhooks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Webhooks',
  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}}/v2/Services/:ServiceSid/Webhooks'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks');

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}}/v2/Services/:ServiceSid/Webhooks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks';
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}}/v2/Services/:ServiceSid/Webhooks"]
                                                       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}}/v2/Services/:ServiceSid/Webhooks" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks",
  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}}/v2/Services/:ServiceSid/Webhooks');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Webhooks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Webhooks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Webhooks' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/Services/:ServiceSid/Webhooks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")

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/v2/Services/:ServiceSid/Webhooks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/Services/:ServiceSid/Webhooks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Webhooks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Webhooks")! 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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Interval=&Max=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid" {:form-params {:Interval ""
                                                                                                                        :Max ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Interval=&Max="

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Interval", "" },
        { "Max", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Interval=&Max=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

	payload := strings.NewReader("Interval=&Max=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 14

Interval=&Max=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Interval=&Max=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Interval=&Max="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Interval=&Max=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Interval=&Max=")
  .asString();

const data = 'Interval=&Max=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Interval', '');
encodedParams.set('Max', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Interval: '', Max: ''})
};

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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Interval: '',
    Max: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Interval=&Max=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({Interval: '', Max: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Interval: '', Max: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Interval: '',
  Max: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Interval', '');
encodedParams.set('Max', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Interval', '');
encodedParams.set('Max', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Interval=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Max=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Interval=&Max=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Interval=&Max=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid', [
  'form_params' => [
    'Interval' => '',
    'Max' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Interval' => '',
  'Max' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Interval' => '',
  'Max' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Interval=&Max='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Interval=&Max='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Interval=&Max="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

payload = {
    "Interval": "",
    "Max": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid"

payload <- "Interval=&Max="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Interval=&Max="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Interval => "",
  :Max => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid";

    let payload = json!({
        "Interval": "",
        "Max": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid \
  content-type:application/x-www-form-urlencoded \
  Interval='' \
  Max=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Interval=&Max=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Interval=".data(using: String.Encoding.utf8)!)
postData.append("&Max=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:RateLimitSid/Buckets/:Sid")! 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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "AuthPayload=&Metadata=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid" {:form-params {:AuthPayload ""
                                                                                                                     :Metadata ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AuthPayload=&Metadata="

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AuthPayload", "" },
        { "Metadata", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AuthPayload=&Metadata=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"

	payload := strings.NewReader("AuthPayload=&Metadata=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 22

AuthPayload=&Metadata=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AuthPayload=&Metadata=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AuthPayload=&Metadata="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "AuthPayload=&Metadata=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AuthPayload=&Metadata=")
  .asString();

const data = 'AuthPayload=&Metadata=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AuthPayload', '');
encodedParams.set('Metadata', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({AuthPayload: '', Metadata: ''})
};

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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AuthPayload: '',
    Metadata: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "AuthPayload=&Metadata=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({AuthPayload: '', Metadata: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {AuthPayload: '', Metadata: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  AuthPayload: '',
  Metadata: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('AuthPayload', '');
encodedParams.set('Metadata', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('AuthPayload', '');
encodedParams.set('Metadata', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"AuthPayload=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Metadata=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AuthPayload=&Metadata=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AuthPayload=&Metadata=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid', [
  'form_params' => [
    'AuthPayload' => '',
    'Metadata' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AuthPayload' => '',
  'Metadata' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'AuthPayload' => '',
  'Metadata' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AuthPayload=&Metadata='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AuthPayload=&Metadata='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "AuthPayload=&Metadata="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"

payload = {
    "AuthPayload": "",
    "Metadata": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid"

payload <- "AuthPayload=&Metadata="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "AuthPayload=&Metadata="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :AuthPayload => "",
  :Metadata => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid";

    let payload = json!({
        "AuthPayload": "",
        "Metadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid \
  content-type:application/x-www-form-urlencoded \
  AuthPayload='' \
  Metadata=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AuthPayload=&Metadata=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "AuthPayload=".data(using: String.Encoding.utf8)!)
postData.append("&Metadata=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Challenges/:Sid")! 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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid" {:form-params {:AuthPayload ""
                                                                                                                  :Config.Alg ""
                                                                                                                  :Config.CodeLength ""
                                                                                                                  :Config.NotificationPlatform ""
                                                                                                                  :Config.NotificationToken ""
                                                                                                                  :Config.SdkVersion ""
                                                                                                                  :Config.Skew ""
                                                                                                                  :Config.TimeStep ""
                                                                                                                  :FriendlyName ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName="

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AuthPayload", "" },
        { "Config.Alg", "" },
        { "Config.CodeLength", "" },
        { "Config.NotificationPlatform", "" },
        { "Config.NotificationToken", "" },
        { "Config.SdkVersion", "" },
        { "Config.Skew", "" },
        { "Config.TimeStep", "" },
        { "FriendlyName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

	payload := strings.NewReader("AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 161

AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=")
  .asString();

const data = 'AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AuthPayload', '');
encodedParams.set('Config.Alg', '');
encodedParams.set('Config.CodeLength', '');
encodedParams.set('Config.NotificationPlatform', '');
encodedParams.set('Config.NotificationToken', '');
encodedParams.set('Config.SdkVersion', '');
encodedParams.set('Config.Skew', '');
encodedParams.set('Config.TimeStep', '');
encodedParams.set('FriendlyName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AuthPayload: '',
    'Config.Alg': '',
    'Config.CodeLength': '',
    'Config.NotificationPlatform': '',
    'Config.NotificationToken': '',
    'Config.SdkVersion': '',
    'Config.Skew': '',
    'Config.TimeStep': '',
    FriendlyName: ''
  })
};

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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AuthPayload: '',
    'Config.Alg': '',
    'Config.CodeLength': '',
    'Config.NotificationPlatform': '',
    'Config.NotificationToken': '',
    'Config.SdkVersion': '',
    'Config.Skew': '',
    'Config.TimeStep': '',
    FriendlyName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  AuthPayload: '',
  'Config.Alg': '',
  'Config.CodeLength': '',
  'Config.NotificationPlatform': '',
  'Config.NotificationToken': '',
  'Config.SdkVersion': '',
  'Config.Skew': '',
  'Config.TimeStep': '',
  FriendlyName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AuthPayload: '',
    'Config.Alg': '',
    'Config.CodeLength': '',
    'Config.NotificationPlatform': '',
    'Config.NotificationToken': '',
    'Config.SdkVersion': '',
    'Config.Skew': '',
    'Config.TimeStep': '',
    FriendlyName: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  AuthPayload: '',
  'Config.Alg': '',
  'Config.CodeLength': '',
  'Config.NotificationPlatform': '',
  'Config.NotificationToken': '',
  'Config.SdkVersion': '',
  'Config.Skew': '',
  'Config.TimeStep': '',
  FriendlyName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('AuthPayload', '');
encodedParams.set('Config.Alg', '');
encodedParams.set('Config.CodeLength', '');
encodedParams.set('Config.NotificationPlatform', '');
encodedParams.set('Config.NotificationToken', '');
encodedParams.set('Config.SdkVersion', '');
encodedParams.set('Config.Skew', '');
encodedParams.set('Config.TimeStep', '');
encodedParams.set('FriendlyName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('AuthPayload', '');
encodedParams.set('Config.Alg', '');
encodedParams.set('Config.CodeLength', '');
encodedParams.set('Config.NotificationPlatform', '');
encodedParams.set('Config.NotificationToken', '');
encodedParams.set('Config.SdkVersion', '');
encodedParams.set('Config.Skew', '');
encodedParams.set('Config.TimeStep', '');
encodedParams.set('FriendlyName', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"AuthPayload=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.Alg=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.CodeLength=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.NotificationPlatform=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.NotificationToken=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.SdkVersion=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.Skew=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Config.TimeStep=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid', [
  'form_params' => [
    'AuthPayload' => '',
    'Config.Alg' => '',
    'Config.CodeLength' => '',
    'Config.NotificationPlatform' => '',
    'Config.NotificationToken' => '',
    'Config.SdkVersion' => '',
    'Config.Skew' => '',
    'Config.TimeStep' => '',
    'FriendlyName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AuthPayload' => '',
  'Config.Alg' => '',
  'Config.CodeLength' => '',
  'Config.NotificationPlatform' => '',
  'Config.NotificationToken' => '',
  'Config.SdkVersion' => '',
  'Config.Skew' => '',
  'Config.TimeStep' => '',
  'FriendlyName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'AuthPayload' => '',
  'Config.Alg' => '',
  'Config.CodeLength' => '',
  'Config.NotificationPlatform' => '',
  'Config.NotificationToken' => '',
  'Config.SdkVersion' => '',
  'Config.Skew' => '',
  'Config.TimeStep' => '',
  'FriendlyName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

payload = {
    "AuthPayload": "",
    "Config.Alg": "",
    "Config.CodeLength": "",
    "Config.NotificationPlatform": "",
    "Config.NotificationToken": "",
    "Config.SdkVersion": "",
    "Config.Skew": "",
    "Config.TimeStep": "",
    "FriendlyName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid"

payload <- "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :AuthPayload => "",
  :Config.Alg => "",
  :Config.CodeLength => "",
  :Config.NotificationPlatform => "",
  :Config.NotificationToken => "",
  :Config.SdkVersion => "",
  :Config.Skew => "",
  :Config.TimeStep => "",
  :FriendlyName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid";

    let payload = json!({
        "AuthPayload": "",
        "Config.Alg": "",
        "Config.CodeLength": "",
        "Config.NotificationPlatform": "",
        "Config.NotificationToken": "",
        "Config.SdkVersion": "",
        "Config.Skew": "",
        "Config.TimeStep": "",
        "FriendlyName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid \
  content-type:application/x-www-form-urlencoded \
  AuthPayload='' \
  Config.Alg='' \
  Config.CodeLength='' \
  Config.NotificationPlatform='' \
  Config.NotificationToken='' \
  Config.SdkVersion='' \
  Config.Skew='' \
  Config.TimeStep='' \
  FriendlyName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AuthPayload=&Config.Alg=&Config.CodeLength=&Config.NotificationPlatform=&Config.NotificationToken=&Config.SdkVersion=&Config.Skew=&Config.TimeStep=&FriendlyName=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "AuthPayload=".data(using: String.Encoding.utf8)!)
postData.append("&Config.Alg=".data(using: String.Encoding.utf8)!)
postData.append("&Config.CodeLength=".data(using: String.Encoding.utf8)!)
postData.append("&Config.NotificationPlatform=".data(using: String.Encoding.utf8)!)
postData.append("&Config.NotificationToken=".data(using: String.Encoding.utf8)!)
postData.append("&Config.SdkVersion=".data(using: String.Encoding.utf8)!)
postData.append("&Config.Skew=".data(using: String.Encoding.utf8)!)
postData.append("&Config.TimeStep=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/Entities/:Identity/Factors/:Sid")! 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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "MessagingServiceSid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country" {:form-params {:MessagingServiceSid ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "MessagingServiceSid="

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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "MessagingServiceSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "MessagingServiceSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

	payload := strings.NewReader("MessagingServiceSid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/Services/:ServiceSid/MessagingConfigurations/:Country HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 20

MessagingServiceSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("MessagingServiceSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("MessagingServiceSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "MessagingServiceSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("MessagingServiceSid=")
  .asString();

const data = 'MessagingServiceSid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('MessagingServiceSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({MessagingServiceSid: ''})
};

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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    MessagingServiceSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "MessagingServiceSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations/:Country',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({MessagingServiceSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {MessagingServiceSid: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  MessagingServiceSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('MessagingServiceSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('MessagingServiceSid', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"MessagingServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"]
                                                       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}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "MessagingServiceSid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "MessagingServiceSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country', [
  'form_params' => [
    'MessagingServiceSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'MessagingServiceSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'MessagingServiceSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'MessagingServiceSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'MessagingServiceSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "MessagingServiceSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations/:Country", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

payload = { "MessagingServiceSid": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country"

payload <- "MessagingServiceSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "MessagingServiceSid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :MessagingServiceSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/Services/:ServiceSid/MessagingConfigurations/:Country') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country";

    let payload = json!({"MessagingServiceSid": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country \
  content-type:application/x-www-form-urlencoded \
  MessagingServiceSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data MessagingServiceSid= \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "MessagingServiceSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/MessagingConfigurations/:Country")! 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}}/v2/Services/:ServiceSid/RateLimits/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Description=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid" {:form-params {:Description ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Description="

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}}/v2/Services/:ServiceSid/RateLimits/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Description", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Description=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

	payload := strings.NewReader("Description=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/Services/:ServiceSid/RateLimits/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 12

Description=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Description=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Description="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Description=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Description=")
  .asString();

const data = 'Description=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Description', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Description: ''})
};

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}}/v2/Services/:ServiceSid/RateLimits/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Description: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Description=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/RateLimits/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({Description: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Description: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Description: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Description', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Description', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Description=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/RateLimits/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Description=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Description=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid', [
  'form_params' => [
    'Description' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Description' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Description' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Description='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Description='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Description="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/RateLimits/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

payload = { "Description": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid"

payload <- "Description="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Description="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Description => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/Services/:ServiceSid/RateLimits/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid";

    let payload = json!({"Description": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid \
  content-type:application/x-www-form-urlencoded \
  Description=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Description= \
  --output-document \
  - {{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Description=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:ServiceSid/RateLimits/:Sid")! 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}}/v2/Services/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/Services/:Sid" {:form-params {:CodeLength ""
                                                                           :CustomCodeEnabled ""
                                                                           :DefaultTemplateSid ""
                                                                           :DoNotShareWarningEnabled ""
                                                                           :DtmfInputRequired ""
                                                                           :FriendlyName ""
                                                                           :LookupEnabled ""
                                                                           :Psd2Enabled ""
                                                                           :Push.ApnCredentialSid ""
                                                                           :Push.FcmCredentialSid ""
                                                                           :Push.IncludeDate ""
                                                                           :SkipSmsToLandlines ""
                                                                           :Totp.CodeLength ""
                                                                           :Totp.Issuer ""
                                                                           :Totp.Skew ""
                                                                           :Totp.TimeStep ""
                                                                           :TtsName ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="

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}}/v2/Services/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "CodeLength", "" },
        { "CustomCodeEnabled", "" },
        { "DefaultTemplateSid", "" },
        { "DoNotShareWarningEnabled", "" },
        { "DtmfInputRequired", "" },
        { "FriendlyName", "" },
        { "LookupEnabled", "" },
        { "Psd2Enabled", "" },
        { "Push.ApnCredentialSid", "" },
        { "Push.FcmCredentialSid", "" },
        { "Push.IncludeDate", "" },
        { "SkipSmsToLandlines", "" },
        { "Totp.CodeLength", "" },
        { "Totp.Issuer", "" },
        { "Totp.Skew", "" },
        { "Totp.TimeStep", "" },
        { "TtsName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:Sid"

	payload := strings.NewReader("CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/Services/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 286

CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=")
  .asString();

const data = 'CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/Services/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('CodeLength', '');
encodedParams.set('CustomCodeEnabled', '');
encodedParams.set('DefaultTemplateSid', '');
encodedParams.set('DoNotShareWarningEnabled', '');
encodedParams.set('DtmfInputRequired', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('LookupEnabled', '');
encodedParams.set('Psd2Enabled', '');
encodedParams.set('Push.ApnCredentialSid', '');
encodedParams.set('Push.FcmCredentialSid', '');
encodedParams.set('Push.IncludeDate', '');
encodedParams.set('SkipSmsToLandlines', '');
encodedParams.set('Totp.CodeLength', '');
encodedParams.set('Totp.Issuer', '');
encodedParams.set('Totp.Skew', '');
encodedParams.set('Totp.TimeStep', '');
encodedParams.set('TtsName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    CodeLength: '',
    CustomCodeEnabled: '',
    DefaultTemplateSid: '',
    DoNotShareWarningEnabled: '',
    DtmfInputRequired: '',
    FriendlyName: '',
    LookupEnabled: '',
    Psd2Enabled: '',
    'Push.ApnCredentialSid': '',
    'Push.FcmCredentialSid': '',
    'Push.IncludeDate': '',
    SkipSmsToLandlines: '',
    'Totp.CodeLength': '',
    'Totp.Issuer': '',
    'Totp.Skew': '',
    'Totp.TimeStep': '',
    TtsName: ''
  })
};

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}}/v2/Services/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    CodeLength: '',
    CustomCodeEnabled: '',
    DefaultTemplateSid: '',
    DoNotShareWarningEnabled: '',
    DtmfInputRequired: '',
    FriendlyName: '',
    LookupEnabled: '',
    Psd2Enabled: '',
    'Push.ApnCredentialSid': '',
    'Push.FcmCredentialSid': '',
    'Push.IncludeDate': '',
    SkipSmsToLandlines: '',
    'Totp.CodeLength': '',
    'Totp.Issuer': '',
    'Totp.Skew': '',
    'Totp.TimeStep': '',
    TtsName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  CodeLength: '',
  CustomCodeEnabled: '',
  DefaultTemplateSid: '',
  DoNotShareWarningEnabled: '',
  DtmfInputRequired: '',
  FriendlyName: '',
  LookupEnabled: '',
  Psd2Enabled: '',
  'Push.ApnCredentialSid': '',
  'Push.FcmCredentialSid': '',
  'Push.IncludeDate': '',
  SkipSmsToLandlines: '',
  'Totp.CodeLength': '',
  'Totp.Issuer': '',
  'Totp.Skew': '',
  'Totp.TimeStep': '',
  TtsName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    CodeLength: '',
    CustomCodeEnabled: '',
    DefaultTemplateSid: '',
    DoNotShareWarningEnabled: '',
    DtmfInputRequired: '',
    FriendlyName: '',
    LookupEnabled: '',
    Psd2Enabled: '',
    'Push.ApnCredentialSid': '',
    'Push.FcmCredentialSid': '',
    'Push.IncludeDate': '',
    SkipSmsToLandlines: '',
    'Totp.CodeLength': '',
    'Totp.Issuer': '',
    'Totp.Skew': '',
    'Totp.TimeStep': '',
    TtsName: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  CodeLength: '',
  CustomCodeEnabled: '',
  DefaultTemplateSid: '',
  DoNotShareWarningEnabled: '',
  DtmfInputRequired: '',
  FriendlyName: '',
  LookupEnabled: '',
  Psd2Enabled: '',
  'Push.ApnCredentialSid': '',
  'Push.FcmCredentialSid': '',
  'Push.IncludeDate': '',
  SkipSmsToLandlines: '',
  'Totp.CodeLength': '',
  'Totp.Issuer': '',
  'Totp.Skew': '',
  'Totp.TimeStep': '',
  TtsName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('CodeLength', '');
encodedParams.set('CustomCodeEnabled', '');
encodedParams.set('DefaultTemplateSid', '');
encodedParams.set('DoNotShareWarningEnabled', '');
encodedParams.set('DtmfInputRequired', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('LookupEnabled', '');
encodedParams.set('Psd2Enabled', '');
encodedParams.set('Push.ApnCredentialSid', '');
encodedParams.set('Push.FcmCredentialSid', '');
encodedParams.set('Push.IncludeDate', '');
encodedParams.set('SkipSmsToLandlines', '');
encodedParams.set('Totp.CodeLength', '');
encodedParams.set('Totp.Issuer', '');
encodedParams.set('Totp.Skew', '');
encodedParams.set('Totp.TimeStep', '');
encodedParams.set('TtsName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('CodeLength', '');
encodedParams.set('CustomCodeEnabled', '');
encodedParams.set('DefaultTemplateSid', '');
encodedParams.set('DoNotShareWarningEnabled', '');
encodedParams.set('DtmfInputRequired', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('LookupEnabled', '');
encodedParams.set('Psd2Enabled', '');
encodedParams.set('Push.ApnCredentialSid', '');
encodedParams.set('Push.FcmCredentialSid', '');
encodedParams.set('Push.IncludeDate', '');
encodedParams.set('SkipSmsToLandlines', '');
encodedParams.set('Totp.CodeLength', '');
encodedParams.set('Totp.Issuer', '');
encodedParams.set('Totp.Skew', '');
encodedParams.set('Totp.TimeStep', '');
encodedParams.set('TtsName', '');

const url = '{{baseUrl}}/v2/Services/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"CodeLength=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CustomCodeEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultTemplateSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DoNotShareWarningEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DtmfInputRequired=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LookupEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Psd2Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Push.ApnCredentialSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Push.FcmCredentialSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Push.IncludeDate=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SkipSmsToLandlines=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Totp.CodeLength=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Totp.Issuer=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Totp.Skew=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Totp.TimeStep=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TtsName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:Sid"]
                                                       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}}/v2/Services/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/Services/:Sid', [
  'form_params' => [
    'CodeLength' => '',
    'CustomCodeEnabled' => '',
    'DefaultTemplateSid' => '',
    'DoNotShareWarningEnabled' => '',
    'DtmfInputRequired' => '',
    'FriendlyName' => '',
    'LookupEnabled' => '',
    'Psd2Enabled' => '',
    'Push.ApnCredentialSid' => '',
    'Push.FcmCredentialSid' => '',
    'Push.IncludeDate' => '',
    'SkipSmsToLandlines' => '',
    'Totp.CodeLength' => '',
    'Totp.Issuer' => '',
    'Totp.Skew' => '',
    'Totp.TimeStep' => '',
    'TtsName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'CodeLength' => '',
  'CustomCodeEnabled' => '',
  'DefaultTemplateSid' => '',
  'DoNotShareWarningEnabled' => '',
  'DtmfInputRequired' => '',
  'FriendlyName' => '',
  'LookupEnabled' => '',
  'Psd2Enabled' => '',
  'Push.ApnCredentialSid' => '',
  'Push.FcmCredentialSid' => '',
  'Push.IncludeDate' => '',
  'SkipSmsToLandlines' => '',
  'Totp.CodeLength' => '',
  'Totp.Issuer' => '',
  'Totp.Skew' => '',
  'Totp.TimeStep' => '',
  'TtsName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'CodeLength' => '',
  'CustomCodeEnabled' => '',
  'DefaultTemplateSid' => '',
  'DoNotShareWarningEnabled' => '',
  'DtmfInputRequired' => '',
  'FriendlyName' => '',
  'LookupEnabled' => '',
  'Psd2Enabled' => '',
  'Push.ApnCredentialSid' => '',
  'Push.FcmCredentialSid' => '',
  'Push.IncludeDate' => '',
  'SkipSmsToLandlines' => '',
  'Totp.CodeLength' => '',
  'Totp.Issuer' => '',
  'Totp.Skew' => '',
  'Totp.TimeStep' => '',
  'TtsName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/Services/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:Sid"

payload = {
    "CodeLength": "",
    "CustomCodeEnabled": "",
    "DefaultTemplateSid": "",
    "DoNotShareWarningEnabled": "",
    "DtmfInputRequired": "",
    "FriendlyName": "",
    "LookupEnabled": "",
    "Psd2Enabled": "",
    "Push.ApnCredentialSid": "",
    "Push.FcmCredentialSid": "",
    "Push.IncludeDate": "",
    "SkipSmsToLandlines": "",
    "Totp.CodeLength": "",
    "Totp.Issuer": "",
    "Totp.Skew": "",
    "Totp.TimeStep": "",
    "TtsName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:Sid"

payload <- "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :CodeLength => "",
  :CustomCodeEnabled => "",
  :DefaultTemplateSid => "",
  :DoNotShareWarningEnabled => "",
  :DtmfInputRequired => "",
  :FriendlyName => "",
  :LookupEnabled => "",
  :Psd2Enabled => "",
  :Push.ApnCredentialSid => "",
  :Push.FcmCredentialSid => "",
  :Push.IncludeDate => "",
  :SkipSmsToLandlines => "",
  :Totp.CodeLength => "",
  :Totp.Issuer => "",
  :Totp.Skew => "",
  :Totp.TimeStep => "",
  :TtsName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/Services/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:Sid";

    let payload = json!({
        "CodeLength": "",
        "CustomCodeEnabled": "",
        "DefaultTemplateSid": "",
        "DoNotShareWarningEnabled": "",
        "DtmfInputRequired": "",
        "FriendlyName": "",
        "LookupEnabled": "",
        "Psd2Enabled": "",
        "Push.ApnCredentialSid": "",
        "Push.FcmCredentialSid": "",
        "Push.IncludeDate": "",
        "SkipSmsToLandlines": "",
        "Totp.CodeLength": "",
        "Totp.Issuer": "",
        "Totp.Skew": "",
        "Totp.TimeStep": "",
        "TtsName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:Sid \
  content-type:application/x-www-form-urlencoded \
  CodeLength='' \
  CustomCodeEnabled='' \
  DefaultTemplateSid='' \
  DoNotShareWarningEnabled='' \
  DtmfInputRequired='' \
  FriendlyName='' \
  LookupEnabled='' \
  Psd2Enabled='' \
  Push.ApnCredentialSid='' \
  Push.FcmCredentialSid='' \
  Push.IncludeDate='' \
  SkipSmsToLandlines='' \
  Totp.CodeLength='' \
  Totp.Issuer='' \
  Totp.Skew='' \
  Totp.TimeStep='' \
  TtsName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'CodeLength=&CustomCodeEnabled=&DefaultTemplateSid=&DoNotShareWarningEnabled=&DtmfInputRequired=&FriendlyName=&LookupEnabled=&Psd2Enabled=&Push.ApnCredentialSid=&Push.FcmCredentialSid=&Push.IncludeDate=&SkipSmsToLandlines=&Totp.CodeLength=&Totp.Issuer=&Totp.Skew=&Totp.TimeStep=&TtsName=' \
  --output-document \
  - {{baseUrl}}/v2/Services/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "CodeLength=".data(using: String.Encoding.utf8)!)
postData.append("&CustomCodeEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultTemplateSid=".data(using: String.Encoding.utf8)!)
postData.append("&DoNotShareWarningEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&DtmfInputRequired=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&LookupEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&Psd2Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Push.ApnCredentialSid=".data(using: String.Encoding.utf8)!)
postData.append("&Push.FcmCredentialSid=".data(using: String.Encoding.utf8)!)
postData.append("&Push.IncludeDate=".data(using: String.Encoding.utf8)!)
postData.append("&SkipSmsToLandlines=".data(using: String.Encoding.utf8)!)
postData.append("&Totp.CodeLength=".data(using: String.Encoding.utf8)!)
postData.append("&Totp.Issuer=".data(using: String.Encoding.utf8)!)
postData.append("&Totp.Skew=".data(using: String.Encoding.utf8)!)
postData.append("&Totp.TimeStep=".data(using: String.Encoding.utf8)!)
postData.append("&TtsName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/Services/:Sid")! 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}}/v2/Services/:ServiceSid/Verifications/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Status=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid" {:form-params {:Status ""}})

require "http/client"

url = "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Status="

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}}/v2/Services/:ServiceSid/Verifications/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Status", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Status=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"

	payload := strings.NewReader("Status=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/Services/:ServiceSid/Verifications/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 7

Status=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Status=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Status="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Status=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Status=")
  .asString();

const data = 'Status=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Status', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Status: ''})
};

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}}/v2/Services/:ServiceSid/Verifications/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Status: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Status=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/Services/:ServiceSid/Verifications/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({Status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Status: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Status', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Status', '');

const url = '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Status=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"]
                                                       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}}/v2/Services/:ServiceSid/Verifications/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Status=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Status=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid', [
  'form_params' => [
    'Status' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Status' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Status' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Status='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Status='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Status="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/Services/:ServiceSid/Verifications/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"

payload = { "Status": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid"

payload <- "Status="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Status="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Status => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/Services/:ServiceSid/Verifications/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid";

    let payload = json!({"Status": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v2/Services/:ServiceSid/Verifications/:Sid \
  content-type:application/x-www-form-urlencoded \
  Status=''